Zelda Classic Coverage Report

Line	Branch	Exec	Source
1			// This program is free software; you can redistribute it and/or modify it under the terms of the
2			// modified version 3 of the GNU General Public License. See License.txt for details.
3
4			//! ritate_sprite_trans doesn't seem to be supported by or allegro header !?
5
6			//glibc 2.28 and later require this: -Z
7			#ifdef __GNUG__
8			#define ALLEGRO_NO_FIX_ALIASES
9			#endif
10
11			#define LOG_BMPBLIT_LEVEL 0
12			#include "precompiled.h" //always first
13
14			#include "base/allegro_wrapper.h"
15			#include "script_drawing.h"
16		11	#include "rendertarget.h"
17			#include "maps.h"
18			#include "tiles.h"
19			#include "zelda.h"
20			#include "ffscript.h"
21			#include "base/util.h"
22			#include "subscr.h"
23			#include "drawing.h"
24			using namespace util;
25			extern FFScript FFCore;
26			extern ZModule zcm;
27			extern refInfo *ri;
28			extern script_bitmaps scb;
29			#include <stdio.h>
30			#include <fstream>
31
32			#define DegtoFix(d) ((d)*0.7111111111111)
33			#define RadtoFix(d) ((d)*40.743665431525)
34
35		✗	inline double sd_log2( double n )
36			{
37			// log(n)/log(2) is log2.
38		✗	double v = log( (double)n ) / log( (double)2 );
39		✗	return v;
40			}
41
42		✗	inline bool isPowerOfTwo(int32_t n)
43			{
44		✗	if(n==0)
45		✗	return false;
46
47		✗	return (ceil(sd_log2(n)) == floor(sd_log2(n)));
48			}
49
50
51
52			template<class T> inline
53		✗	fixed degrees_to_fixed(T d)
54			{
55		✗	return ftofix(DegtoFix(d));
56			}
57			template<class T> inline
58			fixed radians_to_fixed(T d)
59			{
60			return ftofix(RadtoFix(d));
61			}
62
63			BITMAP* ScriptDrawingBitmapPool::_parent_bmp = 0;
64
65
66
67		✗	FONT *get_zc_font(int32_t index)
68			{
69			//return getfont(index);
70		✗	switch(index)
71			{
72			default:
73		✗	return zfont;
74
75			case font_z3font:
76		✗	return z3font;
77
78			case font_z3smallfont:
79		✗	return z3smallfont;
80
81			case font_deffont:
82		✗	return deffont;
83
84			case font_lfont:
85		✗	return lfont;
86
87			case font_lfont_l:
88		✗	return lfont_l;
89
90			case font_pfont:
91		✗	return pfont;
92
93			case font_mfont:
94		✗	return mfont;
95
96			case font_ztfont:
97		✗	return ztfont;
98
99			case font_sfont:
100		✗	return sfont;
101
102			case font_sfont2:
103		✗	return sfont2;
104
105			case font_spfont:
106		✗	return spfont;
107
108			case font_ssfont1:
109		✗	return ssfont1;
110
111			case font_ssfont2:
112		✗	return ssfont2;
113
114			case font_ssfont3:
115		✗	return ssfont3;
116
117			case font_ssfont4:
118		✗	return ssfont4;
119
120			case font_gblafont:
121		✗	return gblafont;
122
123			case font_goronfont:
124		✗	return goronfont;
125
126			case font_zoranfont:
127		✗	return zoranfont;
128
129			case font_hylian1font:
130		✗	return hylian1font;
131
132			case font_hylian2font:
133		✗	return hylian2font;
134
135			case font_hylian3font:
136		✗	return hylian3font;
137
138			case font_hylian4font:
139		✗	return hylian4font;
140
141			case font_gboraclefont:
142		✗	return gboraclefont;
143
144			case font_gboraclepfont:
145		✗	return gboraclepfont;
146
147			case font_dsphantomfont:
148		✗	return dsphantomfont;
149
150			case font_dsphantompfont:
151		✗	return dsphantompfont;
152		✗	case font_atari800font: return atari800font;
153		✗	case font_acornfont: return acornfont;
154		✗	case font_adosfont: return adosfont;
155		✗	case font_baseallegrofont: return baseallegrofont;
156		✗	case font_apple2font: return apple2font;
157		✗	case font_apple280colfont: return apple280colfont;
158		✗	case font_apple2gsfont: return apple2gsfont;
159		✗	case font_aquariusfont: return aquariusfont;
160		✗	case font_atari400font: return atari400font;
161		✗	case font_c64font: return c64font;
162		✗	case font_c64hiresfont: return c64hiresfont;
163		✗	case font_cgafont: return cgafont;
164		✗	case font_cocofont: return cocofont;
165		✗	case font_coco2font: return coco2font;
166		✗	case font_coupefon: return coupefont;
167		✗	case font_cpcfon: return cpcfont;
168		✗	case font_fantasyfon: return fantasyfont;
169		✗	case font_fdskanafon: return fdskanafont;
170		✗	case font_fdslikefon: return fdslikefont;
171		✗	case font_fdsromanfon: return fdsromanfont;
172		✗	case font_finalffont: return finalffont;
173		✗	case font_futharkfont: return futharkfont;
174		✗	case font_gaiafont: return gaiafont;
175		✗	case font_hirafont: return hirafont;
176		✗	case font_jpfont: return jpfont;
177		✗	case font_kongfont: return kongfont;
178		✗	case font_manafont: return manafont;
179		✗	case font_mlfont: return mlfont;
180		✗	case font_motfont: return motfont;
181		✗	case font_msxmode0font: return msxmode0font;
182		✗	case font_msxmode1font: return msxmode1font;
183		✗	case font_petfont: return petfont;
184		✗	case font_pstartfont: return pstartfont;
185		✗	case font_saturnfont: return saturnfont;
186		✗	case font_scififont: return scififont;
187		✗	case font_sherwoodfont: return sherwoodfont;
188		✗	case font_sinqlfont: return sinqlfont;
189		✗	case font_spectrumfont: return spectrumfont;
190		✗	case font_speclgfont: return speclgfont;
191		✗	case font_ti99font: return ti99font;
192		✗	case font_trsfont: return trsfont;
193		✗	case font_z2font: return z2font;
194		✗	case font_zxfont: return zxfont;
195		✗	case font_lisafont: return lisafont;
196			}
197			}
198
199
200			class TileHelper
201			{
202			public:
203
204		✗	static void OldPutTile(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, byte skiprows=0)
205			{
206			// Past the end of the tile page?
207		✗	if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
208			{
209		✗	byte w2=(tile+w)%TILES_PER_ROW;
210		✗	OldPutTile(_Dest, tile, x, y, w-w2, h, color, flip);
211		✗	OldPutTile(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, color, flip);
212		✗	return;
213			}
214
215		✗	switch(flip)
216			{
217			case 1:
218		✗	for(int32_t j=0; j<h; j++)
219		✗	for(int32_t k=w-1; k>=0; k--)
220		✗	oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, color, flip);
221
222		✗	break;
223
224			case 2:
225		✗	for(int32_t j=h-1; j>=0; j--)
226		✗	for(int32_t k=0; k<w; k++)
227		✗	oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, color, flip);
228
229		✗	break;
230
231			case 3:
232		✗	for(int32_t j=h-1; j>=0; j--)
233		✗	for(int32_t k=w-1; k>=0; k--)
234		✗	oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, color, flip);
235
236		✗	break;
237
238		✗	case 0:
239			default:
240		✗	for(int32_t j=0; j<h; j++)
241		✗	for(int32_t k=0; k<w; k++)
242		✗	oldputtile16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, color, flip);
243
244		✗	break;
245			}
246			}
247
248		✗	static void OverTile(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, byte skiprows=0)
249			{
250		✗	overtileblock16(_Dest,tile,x,y,w,h,color,flip,skiprows);
251			}
252
253		✗	static void OverTileCloaked(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t flip, byte skiprows=0)
254			{
255		✗	if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
256			{
257		✗	byte w2=(tile+w)%TILES_PER_ROW;
258		✗	OverTileCloaked(_Dest, tile, x, y, w-w2, h, flip);
259		✗	OverTileCloaked(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, flip);
260		✗	return;
261			}
262
263		✗	switch(flip)
264			{
265			case 1:
266		✗	for(int32_t j=0; j<h; j++)
267		✗	for(int32_t k=w-1; k>=0; k--)
268		✗	overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, flip);
269
270		✗	break;
271
272			case 2:
273		✗	for(int32_t j=h-1; j>=0; j--)
274		✗	for(int32_t k=0; k<w; k++)
275		✗	overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, flip);
276
277		✗	break;
278
279			case 3:
280		✗	for(int32_t j=h-1; j>=0; j--)
281		✗	for(int32_t k=w-1; k>=0; k--)
282		✗	overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, flip);
283
284		✗	break;
285
286			default:
287		✗	for(int32_t j=0; j<h; j++)
288		✗	for(int32_t k=0; k<w; k++)
289		✗	overtilecloaked16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, flip);
290
291		✗	break;
292			}
293			}
294
295		✗	static void OverTileTranslucent(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, int32_t opacity, byte skiprows=0)
296			{
297		✗	if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
298			{
299		✗	byte w2=(tile+w)%TILES_PER_ROW;
300		✗	OverTileTranslucent(_Dest, tile, x, y, w-w2, h, color, flip, opacity);
301		✗	OverTileTranslucent(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, color, flip, opacity);
302		✗	return;
303			}
304
305		✗	switch(flip)
306			{
307			case 1:
308		✗	for(int32_t j=0; j<h; j++)
309		✗	for(int32_t k=w-1; k>=0; k--)
310		✗	overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, color, flip, opacity);
311
312		✗	break;
313
314			case 2:
315		✗	for(int32_t j=h-1; j>=0; j--)
316		✗	for(int32_t k=0; k<w; k++)
317		✗	overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, color, flip, opacity);
318
319		✗	break;
320
321			case 3:
322		✗	for(int32_t j=h-1; j>=0; j--)
323		✗	for(int32_t k=w-1; k>=0; k--)
324		✗	overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, color, flip, opacity);
325
326		✗	break;
327
328			default:
329		✗	for(int32_t j=0; j<h; j++)
330		✗	for(int32_t k=0; k<w; k++)
331		✗	overtiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, color, flip, opacity);
332
333		✗	break;
334			}
335			}
336
337		✗	static void PutTileTranslucent(BITMAP* _Dest, int32_t tile, int32_t x, int32_t y, int32_t w, int32_t h, int32_t color, int32_t flip, int32_t opacity, byte skiprows=0)
338			{
339		✗	if(skiprows>0 && tile%TILES_PER_ROW+w>=TILES_PER_ROW)
340			{
341		✗	byte w2=(tile+w)%TILES_PER_ROW;
342		✗	PutTileTranslucent(_Dest, tile, x, y, w-w2, h, color, flip, opacity);
343		✗	PutTileTranslucent(_Dest, tile+(w-w2)+(skiprows*TILES_PER_ROW), x+16*(w-w2), y, w2, h, color, flip, opacity);
344		✗	return;
345			}
346
347		✗	switch(flip)
348			{
349			case 1:
350		✗	for(int32_t j=0; j<h; j++)
351		✗	for(int32_t k=w-1; k>=0; k--)
352		✗	puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+j*16, color, flip, opacity);
353
354		✗	break;
355
356			case 2:
357		✗	for(int32_t j=h-1; j>=0; j--)
358		✗	for(int32_t k=0; k<w; k++)
359		✗	puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+((h-1)-j)*16, color, flip, opacity);
360
361		✗	break;
362
363			case 3:
364		✗	for(int32_t j=h-1; j>=0; j--)
365		✗	for(int32_t k=w-1; k>=0; k--)
366		✗	puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+((w-1)-k)*16, y+((h-1)-j)*16, color, flip, opacity);
367
368		✗	break;
369
370			default:
371		✗	for(int32_t j=0; j<h; j++)
372		✗	for(int32_t k=0; k<w; k++)
373		✗	puttiletranslucent16(_Dest, tile+(j*TILES_PER_ROW)+k, x+k*16, y+j*16, color, flip, opacity);
374
375		✗	break;
376			}
377			}
378			};
379
380
381
382
383		✗	void do_rectr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
384			{
385			//sdci[1]=layer
386			//sdci[2]=x
387			//sdci[3]=y
388			//sdci[4]=x2
389			//sdci[5]=y2
390			//sdci[6]=color
391			//sdci[7]=scale factor
392			//sdci[8]=rotation anchor x
393			//sdci[9]=rotation anchor y
394			//sdci[10]=rotation angle
395			//sdci[11]=fill
396			//sdci[12]=opacity
397		✗	if(sdci[7]==0) //scale
398			{
399		✗	return;
400			}
401
402		✗	int32_t x1=sdci[2]/10000;
403		✗	int32_t y1=sdci[3]/10000;
404		✗	int32_t x2=sdci[4]/10000;
405		✗	int32_t y2=sdci[5]/10000;
406
407		✗	if(x1>x2)
408			{
409		✗	zc_swap(x1,x2);
410			}
411
412		✗	if(y1>y2)
413			{
414		✗	zc_swap(y1,y2);
415			}
416
417		✗	if(sdci[7] != 10000)
418			{
419		✗	int32_t w=x2-x1+1;
420		✗	int32_t h=y2-y1+1;
421		✗	int32_t w2=(w*sdci[7])/10000;
422		✗	int32_t h2=(h*sdci[7])/10000;
423		✗	x1=x1-((w2-w)/2);
424		✗	x2=x2+((w2-w)/2);
425		✗	y1=y1-((h2-h)/2);
426		✗	y2=y2+((h2-h)/2);
427			}
428
429		✗	int32_t color=sdci[6]/10000;
430
431		✗	if(sdci[12]/10000<=127) //translucent
432			{
433		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
434			}
435
436		✗	if(sdci[10]==0) //no rotation
437			{
438		✗	if(sdci[11]) //filled
439			{
440		✗	rectfill(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
441			}
442			else //outline
443			{
444		✗	rect(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
445			}
446			}
447			else //rotate
448			{
449			int32_t xy[16];
450		✗	int32_t rx=sdci[8]/10000;
451		✗	int32_t ry=sdci[9]/10000;
452		✗	fixed ra1=itofix(sdci[10]%10000)/10000;
453		✗	fixed ra2=itofix(sdci[10]/10000);
454		✗	fixed ra=ra1+ra2;
455		✗	ra = (ra/360)*256;
456
457		✗	fixed fcosa = fixcos(ra);
458		✗	fixed fsina = fixsin(ra);
459
460		✗	xy[ 0]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry))); //x1
461		✗	xy[ 1]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry))); //y1
462		✗	xy[ 2]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y1 - ry))); //x2
463		✗	xy[ 3]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y1 - ry))); //y1
464		✗	xy[ 4]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry))); //x2
465		✗	xy[ 5]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry))); //y2
466		✗	xy[ 6]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y2 - ry))); //x1
467		✗	xy[ 7]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y2 - ry))); //y2
468		✗	xy[ 8]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry + 1))); //x1
469		✗	xy[ 9]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry + 1))); //y1
470		✗	xy[10]=xoffset+rx + fixtoi((fcosa * (x2 - rx - 1) - fsina * (y1 - ry))); //x2
471		✗	xy[11]=yoffset+ry + fixtoi((fsina * (x2 - rx - 1) + fcosa * (y1 - ry))); //y1
472		✗	xy[12]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry - 1))); //x2
473		✗	xy[13]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry - 1))); //y2
474		✗	xy[14]=xoffset+rx + fixtoi((fcosa * (x1 - rx + 1) - fsina * (y2 - ry))); //x1
475		✗	xy[15]=yoffset+ry + fixtoi((fsina * (x1 - rx + 1) + fcosa * (y2 - ry))); //y2
476
477		✗	if(sdci[11]) //filled
478			{
479		✗	polygon(bmp, 4, xy, color);
480			}
481			else //outline
482			{
483		✗	line(bmp, xy[0], xy[1], xy[10], xy[11], color);
484		✗	line(bmp, xy[2], xy[3], xy[12], xy[13], color);
485		✗	line(bmp, xy[4], xy[5], xy[14], xy[15], color);
486		✗	line(bmp, xy[6], xy[7], xy[ 8], xy[ 9], color);
487			}
488			}
489
490		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
491			}
492
493		✗	void do_framer(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
494			{
495			//sdci[1]=layer
496			//sdci[2]=x
497			//sdci[3]=y
498			//sdci[4]=tile
499			//sdci[5]=cset
500			//sdci[6]=width
501			//sdci[7]=height
502			//sdci[8]=overlay
503			//sdci[9]=opacity
504
505		✗	int32_t x=sdci[2]/10000;
506		✗	int32_t y=sdci[3]/10000;
507
508		✗	int32_t tile=sdci[4]/10000;
509		✗	int32_t cs=sdci[5]/10000;
510		✗	int32_t w=sdci[6]/10000;
511		✗	int32_t h=sdci[7]/10000;
512		✗	bool overlay=sdci[8];
513		✗	bool trans=(sdci[9]/10000<=127);
514
515		✗	frame2x2(bmp, &QMisc, x + xoffset, y + yoffset, tile, cs, w, h, 0, overlay, trans);
516			}
517
518
519
520		✗	void do_circler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
521			{
522			//sdci[1]=layer
523			//sdci[2]=x
524			//sdci[3]=y
525			//sdci[4]=radius
526			//sdci[5]=color
527			//sdci[6]=scale factor
528			//sdci[7]=rotation anchor x
529			//sdci[8]=rotation anchor y
530			//sdci[9]=rotation angle
531			//sdci[10]=fill
532			//sdci[11]=opacity
533		✗	if(sdci[6]==0) //scale
534			{
535		✗	return;
536			}
537
538		✗	int32_t x1=sdci[2]/10000;
539		✗	int32_t y1=sdci[3]/10000;
540		✗	qword r=sdci[4];
541
542		✗	if(sdci[6] != 10000)
543			{
544		✗	r*=sdci[6];
545		✗	r/=10000;
546			}
547
548		✗	r/=10000;
549		✗	int32_t color=sdci[5]/10000;
550
551		✗	if(sdci[11]/10000<=127) //translucent
552			{
553		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
554			}
555
556		✗	if(sdci[9]!=0&&(sdci[2]!=sdci[7]||sdci[3]!=sdci[8])) //rotation
557			{
558			int32_t xy[2];
559		✗	int32_t rx=sdci[7]/10000;
560		✗	int32_t ry=sdci[8]/10000;
561		✗	fixed ra1=itofix(sdci[9]%10000)/10000;
562		✗	fixed ra2=itofix(sdci[9]/10000);
563		✗	fixed ra=ra1+ra2;
564		✗	ra = (ra/360)*256;
565
566		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
567		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
568		✗	x1=xy[0];
569		✗	y1=xy[1];
570			}
571
572		✗	if(sdci[10]) //filled
573			{
574		✗	circlefill(bmp, x1+xoffset, y1+yoffset, r, color);
575			}
576			else //outline
577			{
578		✗	circle(bmp, x1+xoffset, y1+yoffset, r, color);
579			}
580
581		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
582			}
583
584
585		✗	void do_arcr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
586			{
587			//sdci[1]=layer
588			//sdci[2]=x
589			//sdci[3]=y
590			//sdci[4]=radius
591			//sdci[5]=start angle
592			//sdci[6]=end angle
593			//sdci[7]=color
594			//sdci[8]=scale factor
595			//sdci[9]=rotation anchor x
596			//sdci[10]=rotation anchor y
597			//sdci[11]=rotation angle
598			//sdci[12]=closed
599			//sdci[13]=fill
600			//sdci[14]=opacity
601
602		✗	if(sdci[8]==0) //scale
603			{
604		✗	return;
605			}
606
607		✗	int32_t cx=sdci[2]/10000;
608		✗	int32_t cy=sdci[3]/10000;
609		✗	qword r=sdci[4];
610
611		✗	if(sdci[8] != 10000)
612			{
613		✗	r*=sdci[8];
614		✗	r/=10000;
615			}
616
617		✗	r/=10000;
618
619		✗	int32_t color=sdci[7]/10000;
620
621		✗	fixed ra1=itofix(sdci[11]%10000)/10000;
622		✗	fixed ra2=itofix(sdci[11]/10000);
623		✗	fixed ra=ra1+ra2;
624		✗	ra = (ra/360)*256;
625
626
627		✗	fixed a1=itofix(sdci[5]%10000)/10000;
628		✗	fixed a2=itofix(sdci[5]/10000);
629		✗	fixed sa=a1+a2;
630		✗	sa = (sa/360)*256;
631
632		✗	a1=itofix(sdci[6]%10000)/10000;
633		✗	a2=itofix(sdci[6]/10000);
634		✗	fixed ea=a1+a2;
635		✗	ea = (ea/360)*256;
636
637		✗	if(sdci[11]!=0) //rotation
638			{
639		✗	int32_t rx=sdci[9]/10000;
640		✗	int32_t ry=sdci[10]/10000;
641
642		✗	cx=rx + fixtoi((fixcos(ra) * (cx - rx) - fixsin(ra) * (cy - ry))); //x1
643		✗	cy=ry + fixtoi((fixsin(ra) * (cx - rx) + fixcos(ra) * (cy - ry))); //y1
644		✗	ea-=ra;
645		✗	sa-=ra;
646			}
647
648		✗	int32_t fx=cx+fixtoi(fixcos(-(ea+sa)/2)*r/2);
649		✗	int32_t fy=cy+fixtoi(fixsin(-(ea+sa)/2)*r/2);
650
651		✗	if(sdci[12]) //closed
652			{
653		✗	if(sdci[13]) //filled
654			{
655		✗	clear_bitmap(prim_bmp);
656		✗	arc(prim_bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
657		✗	line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
658		✗	line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
659		✗	floodfill(prim_bmp, zc_max(0,fx)+xoffset, zc_max(0,fy)+yoffset, color);
660
661		✗	if(sdci[14]/10000<=127) //translucent
662			{
663		✗	draw_trans_sprite(bmp, prim_bmp, 0,0);
664			}
665			else
666			{
667		✗	draw_sprite(bmp, prim_bmp, 0,0);
668			}
669			}
670			else
671			{
672		✗	arc(bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
673		✗	line(bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
674		✗	line(bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
675			}
676			}
677			else
678			{
679		✗	if(sdci[14]/10000<=127) //translucent
680			{
681		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
682			}
683
684		✗	arc(bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
685		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
686			}
687			}
688
689
690		✗	void do_ellipser(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
691			{
692			//sdci[1]=layer
693			//sdci[2]=x
694			//sdci[3]=y
695			//sdci[4]=radiusx
696			//sdci[5]=radiusy
697			//sdci[6]=color
698			//sdci[7]=scale factor
699			//sdci[8]=rotation anchor x
700			//sdci[9]=rotation anchor y
701			//sdci[10]=rotation angle
702			//sdci[11]=fill
703			//sdci[12]=opacity
704
705		✗	if(sdci[7]==0) //scale
706			{
707		✗	return;
708			}
709
710		✗	int32_t x1=sdci[2]/10000;
711		✗	int32_t y1=sdci[3]/10000;
712		✗	int32_t radx=sdci[4]/10000;
713		✗	radx*=sdci[7]/10000;
714		✗	int32_t rady=sdci[5]/10000;
715		✗	rady*=sdci[7]/10000;
716		✗	int32_t color=sdci[6]/10000;
717		✗	float rotation = sdci[10]/10000;
718
719		✗	int32_t rx=sdci[8]/10000;
720		✗	int32_t ry=sdci[9]/10000;
721		✗	fixed ra1=itofix(sdci[10]%10000)/10000;
722		✗	fixed ra2=itofix(sdci[10]/10000);
723		✗	fixed ra=ra1+ra2;
724		✗	ra = (ra/360)*256;
725
726			int32_t xy[2];
727		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
728		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
729		✗	x1=xy[0];
730		✗	y1=xy[1];
731
732		✗	if(radx<1||rady<1||radx>255||rady>255) return;
733
734		✗	BITMAP* bitty = script_drawing_commands.AquireSubBitmap(radx*2+1, rady*2+1);
735
736		✗	if(sdci[11]) //filled
737			{
738
739		✗	if(sdci[12]/10000<128) //translucent
740			{
741		✗	clear_bitmap(prim_bmp);
742		✗	ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
743		✗	rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
744		✗	draw_trans_sprite(bmp, prim_bmp, 0, 0);
745			}
746			else // no opacity
747			{
748		✗	ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
749		✗	rotate_sprite(bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
750			}
751			}
752			else //not filled
753			{
754		✗	if(sdci[12]/10000<128) //translucent
755			{
756		✗	clear_bitmap(prim_bmp);
757		✗	ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
758		✗	rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
759		✗	draw_trans_sprite(bmp, prim_bmp, 0, 0);
760			}
761			else // no opacity
762			{
763		✗	ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
764		✗	rotate_sprite(bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
765			}
766			}
767
768			// Since 0 is the transparent color, the stuff above will fail if the ellipse color is also 0.
769			// Instead, it uses color 255 and replaces it afterward. That'll also screw up color 255 around
770			// the ellipse, but it shouldn't be used anyway.
771		✗	if(color==0)
772			{
773			// This is very slow, so check the smallest possible square
774		✗	int32_t endx=zc_min(bmp->w-1, x1+zc_max(radx, rady));
775		✗	int32_t endy=zc_min(bmp->h-1, y1+zc_max(radx, rady));
776
777		✗	for(int32_t y=zc_max(0, y1-zc_max(radx, rady)); y<=endy; y++)
778		✗	for(int32_t x=zc_max(0, x1-zc_max(radx, rady)); x<=endx; x++)
779		✗	if(getpixel(bmp, x, y)==255)
780		✗	putpixel(bmp, x, y, 0);
781			}
782
783		✗	script_drawing_commands.ReleaseSubBitmap(bitty);
784			}
785
786
787		✗	void do_liner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
788			{
789			//sdci[1]=layer
790			//sdci[2]=x
791			//sdci[3]=y
792			//sdci[4]=x2
793			//sdci[5]=y2
794			//sdci[6]=color
795			//sdci[7]=scale factor
796			//sdci[8]=rotation anchor x
797			//sdci[9]=rotation anchor y
798			//sdci[10]=rotation angle
799			//sdci[11]=opacity
800		✗	if(sdci[7]==0) //scale
801			{
802		✗	return;
803			}
804
805		✗	int32_t x1=sdci[2]/10000;
806		✗	int32_t y1=sdci[3]/10000;
807		✗	int32_t x2=sdci[4]/10000;
808		✗	int32_t y2=sdci[5]/10000;
809
810		✗	if(sdci[7] != 10000)
811			{
812		✗	int32_t w=x2-x1+1;
813		✗	int32_t h=y2-y1+1;
814		✗	int32_t w2=int32_t(w*((double)sdci[7]/10000.0));
815		✗	int32_t h2=int32_t(h*((double)sdci[7]/10000.0));
816		✗	x1=x1-((w2-w)/2);
817		✗	x2=x2+((w2-w)/2);
818		✗	y1=y1-((h2-h)/2);
819		✗	y2=y2+((h2-h)/2);
820			}
821
822		✗	int32_t color=sdci[6]/10000;
823
824		✗	if(sdci[11]/10000<=127) //translucent
825			{
826		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
827			}
828
829		✗	if(sdci[10]!=0) //rotation
830			{
831			int32_t xy[4];
832		✗	int32_t rx=sdci[8]/10000;
833		✗	int32_t ry=sdci[9]/10000;
834		✗	fixed ra1=itofix(sdci[10]%10000)/10000;
835		✗	fixed ra2=itofix(sdci[10]/10000);
836		✗	fixed ra=ra1+ra2;
837
838		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
839		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
840		✗	xy[ 2]=rx + fixtoi((fixcos(ra) * (x2 - rx) - fixsin(ra) * (y2 - ry))); //x2
841		✗	xy[ 3]=ry + fixtoi((fixsin(ra) * (x2 - rx) + fixcos(ra) * (y2 - ry))); //y2
842		✗	x1=xy[0];
843		✗	y1=xy[1];
844		✗	x2=xy[2];
845		✗	y2=xy[3];
846			}
847
848		✗	line(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
849		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
850			}
851
852		✗	void do_linesr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
853			{
854			//sdci[1]=layer
855			//sdci[2]=array[10] = { x, y, x2, y2, colour, scale, rx, ry, angle, opacity }
856
857			//sdci[2]=x
858			//sdci[3]=y
859			//sdci[4]=x2
860			//sdci[5]=y2
861			//sdci[6]=color
862			//sdci[7]=scale factor
863			//sdci[8]=rotation anchor x
864			//sdci[9]=rotation anchor y
865			//sdci[10]=rotation angle
866			//sdci[11]=opacity
867			//if(sdci[7]==0) //scale
868			//{
869			// return;
870			//}
871
872		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
873
874		✗	if(!v_ptr)
875			{
876		✗	al_trace("Screen->PutPixels: Vector pointer is null! Internal error. \n");
877		✗	return;
878			}
879
880		✗	std::vector<int32_t> &v = *v_ptr;
881
882		✗	if(v.empty())
883		✗	return;
884			//Z_scripterrlog("PutPixels reached line %d\n", 983);
885
886		✗	int32_t* pos = &v[0];
887		✗	int32_t sz = v.size();
888
889		✗	for ( int32_t q = 0; q < sz; q+=10 )
890			{
891
892		✗	int32_t x1 = v.at(q);
893		✗	Z_scripterrlog("Lines( x1 ) is: %d\n", x1);
894		✗	int32_t y1 = v.at(q+1);
895		✗	Z_scripterrlog("Lines( x2 ) is: %d\n", y1);
896		✗	int32_t x2 = v.at(q+2);
897		✗	Z_scripterrlog("Lines( x2 ) is: %d\n", x2);
898		✗	int32_t y2 = v.at(q+3);
899		✗	Z_scripterrlog("Lines( y2 ) is: %d\n", y2);
900		✗	int32_t color = v.at(q+4);
901		✗	Z_scripterrlog("Lines( colour ) is: %d\n", color);
902		✗	Z_scripterrlog("Lines( scale ) is: %d\n", v.at(q+5));
903		✗	if (v.at(q+5) == 0) { Z_scripterrlog("Lines() aborting due to scale\n"); return; }//scale
904
905		✗	if( v.at(q+5) != 10000)
906			{
907		✗	int32_t w=x2-x1+1;
908		✗	int32_t h=y2-y1+1;
909		✗	int32_t w2=int32_t(w*((double)v.at(q+5)));
910		✗	int32_t h2=int32_t(h*((double)v.at(q+5)));
911		✗	x1=x1-((w2-w)/2);
912		✗	x2=x2+((w2-w)/2);
913		✗	y1=y1-((h2-h)/2);
914		✗	y2=y2+((h2-h)/2);
915			}
916
917
918		✗	Z_scripterrlog("Lines( opacity ) is: %d\n", v.at(q+9));
919		✗	if(v.at(q+9) <= 127) //translucent
920			{
921		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
922			}
923		✗	else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
924		✗	Z_scripterrlog("Lines( rotation ) is: %d\n", v.at(q+8));
925		✗	Z_scripterrlog("Lines( rot_x ) is: %d\n", v.at(q+6));
926		✗	Z_scripterrlog("Lines( rot_x ) is: %d\n", v.at(q+7));
927		✗	if( v.at(q+8) !=0 ) //rotation
928			{
929			int32_t xy[4];
930
931		✗	int32_t rx = v.at(q+6);
932
933		✗	int32_t ry = v.at(q+7);
934
935		✗	fixed ra1=itofix(v.at(q+8) % 1);
936		✗	fixed ra2=itofix(v.at(q+8));
937		✗	fixed ra=ra1+ra2;
938
939		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
940		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
941		✗	xy[ 2]=rx + fixtoi((fixcos(ra) * (x2 - rx) - fixsin(ra) * (y2 - ry))); //x2
942		✗	xy[ 3]=ry + fixtoi((fixsin(ra) * (x2 - rx) + fixcos(ra) * (y2 - ry))); //y2
943		✗	x1=xy[0];
944		✗	y1=xy[1];
945		✗	x2=xy[2];
946		✗	y2=xy[3];
947			}
948		✗	Z_scripterrlog("Lines( xofs ) is: %d\n", xoffset);
949		✗	Z_scripterrlog("Lines( yofs ) is: %d\n", yoffset);
950		✗	line(bmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
951			}
952		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
953			}
954
955		✗	void do_polygonr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
956			{
957			//sdci[1]=layer
958			//sdci[2]=point count
959			//sdci[3]array[]
960			//sdci[4] = colour
961			//sdci[5] = opacity
962
963		✗	int32_t col = sdci[4]/10000;
964		✗	int32_t op = sdci[5]/10000;
965
966			//bool brokenOffset= ( (get_bit(extra_rules, er_BITMAPOFFSET)!=0) || (get_bit(quest_rules,qr_BITMAPOFFSETFIX)!=0) );
967			//Z_scripterrlog("Broken offset rule for Polygon() is: %s\n", brokenOffset ? "ON" : "OFF");
968		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
969
970		✗	if(!v_ptr)
971			{
972		✗	al_trace("Screen->Polygon: Vector pointer is null! Internal error. \n");
973		✗	return;
974			}
975
976		✗	std::vector<int32_t> &v = *v_ptr;
977
978		✗	if(v.empty())
979		✗	return;
980			//Z_scripterrlog("PutPixels reached line %d\n", 983);
981
982		✗	int32_t* pos = &v[0];
983		✗	int32_t sz = v.size();
984		✗	int32_t numpoints = (sdci[2]/10000);
985		✗	if(sz & 1) --sz; //even amount only
986		✗	if(numpoints > sz/2) //cap to array
987		✗	numpoints = sz/2;
988		✗	if(numpoints < 1)
989		✗	return; //Don't draw 0 or negative point count
990
991			//Fix the draw Y offset. -Z 20th June, 2019
992		✗	for ( int32_t q = 1; q < sz; q+=2 )
993			{
994		✗	pos[q] += yoffset;
995			}
996		✗	if(op <= 127) //translucent
997			{
998		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
999			}
1000		✗	else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1001
1002		✗	polygon(bmp, numpoints, (int32_t*)pos, col);
1003			//polygon(bmp, (sdci[2]/10000), &v, col);
1004		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1005			}
1006
1007		✗	void bmp_do_polygonr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1008			{
1009			//sdci[1]=layer
1010			//sdci[2]=point count
1011			//sdci[3]array[]
1012			//sdci[4] = colour
1013			//sdci[5] = opacity
1014
1015		✗	int32_t col = sdci[4]/10000;
1016		✗	int32_t op = sdci[5]/10000;
1017
1018		✗	if ( sdci[17] <= 0 )
1019			{
1020		✗	Z_scripterrlog("bitmap->Rectangle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
1021		✗	return;
1022			}
1023		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
1024		✗	if ( refbmp == NULL ) return;
1025
1026		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
1027
1028		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1029
1030		✗	if(!v_ptr)
1031			{
1032		✗	al_trace("Screen->Polygon: Vector pointer is null! Internal error. \n");
1033		✗	return;
1034			}
1035
1036		✗	std::vector<int32_t> &v = *v_ptr;
1037
1038		✗	if(v.empty())
1039		✗	return;
1040			//Z_scripterrlog("PutPixels reached line %d\n", 983);
1041
1042		✗	int32_t* pos = &v[0];
1043		✗	int32_t sz = v.size();
1044		✗	int32_t numpoints = (sdci[2]/10000);
1045		✗	if(sz & 1) --sz; //even amount only
1046		✗	if(numpoints > sz/2) //cap to array
1047		✗	numpoints = sz/2;
1048		✗	if(numpoints < 1)
1049		✗	return; //Don't draw 0 or negative point count
1050
1051			//Fix the draw Y offset. -Z 20th June, 2019
1052		✗	for ( int32_t q = 1; q < sz; q+=2 )
1053			{
1054		✗	pos[q] += yoffset;
1055			}
1056		✗	if(op <= 127) //translucent
1057			{
1058		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1059			}
1060		✗	else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1061
1062		✗	polygon(refbmp, numpoints, (int32_t*)pos, col);
1063			//polygon(refbmp, (sdci[2]/10000), &v, col);
1064		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1065			}
1066
1067		✗	void do_spliner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1068			{
1069			/* layer, x1, y1, x2, y2, x3, y3, x4, y4, color, opacity */
1070
1071		✗	int32_t points[8] = { xoffset + (sdci[2]/10000), yoffset + (sdci[3]/10000),
1072		✗	xoffset + (sdci[4]/10000), yoffset + (sdci[5]/10000),
1073		✗	xoffset + (sdci[6]/10000), yoffset + (sdci[7]/10000),
1074		✗	xoffset + (sdci[8]/10000), yoffset + (sdci[9]/10000)
1075			};
1076
1077		✗	if(sdci[11]/10000 < 128) //translucent
1078			{
1079		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1080			}
1081
1082		✗	spline(bmp, points, sdci[10]/10000);
1083
1084		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1085			}
1086
1087
1088		✗	void do_putpixelr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1089			{
1090			//sdci[1]=layer
1091			//sdci[2]=x
1092			//sdci[3]=y
1093			//sdci[4]=color
1094			//sdci[5]=rotation anchor x
1095			//sdci[6]=rotation anchor y
1096			//sdci[7]=rotation angle
1097			//sdci[8]=opacity
1098		✗	int32_t x1=sdci[2]/10000;
1099		✗	int32_t y1=sdci[3]/10000;
1100		✗	int32_t color=sdci[4]/10000;
1101
1102		✗	if(sdci[8]/10000<=127) //translucent
1103			{
1104		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1105			}
1106
1107		✗	if(sdci[7]!=0) //rotation
1108			{
1109			int32_t xy[2];
1110		✗	int32_t rx=sdci[5]/10000;
1111		✗	int32_t ry=sdci[6]/10000;
1112		✗	fixed ra1=itofix(sdci[7]%10000)/10000;
1113		✗	fixed ra2=itofix(sdci[7]/10000);
1114		✗	fixed ra=ra1+ra2;
1115
1116		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1117		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1118		✗	x1=xy[0];
1119		✗	y1=xy[1];
1120			}
1121
1122		✗	putpixel(bmp, x1+xoffset, y1+yoffset, color);
1123		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1124			}
1125
1126		✗	void do_putpixelsr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1127			{
1128			//Z_scripterrlog("Starting putpixels()%s\n");
1129			//sdci[1]=layer
1130			//sdci[2]=array {x,y,colour,opacity}
1131			//sdci[3]=rotation anchor x
1132			//sdci[4]=rotation anchor y
1133			//sdci[5]=rotation angle
1134
1135
1136		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1137
1138		✗	if(!v_ptr)
1139			{
1140		✗	al_trace("Screen->PutPixels: Vector pointer is null! Internal error. \n");
1141		✗	return;
1142			}
1143
1144		✗	std::vector<int32_t> &v = *v_ptr;
1145
1146		✗	if(v.empty())
1147		✗	return;
1148			//Z_scripterrlog("PutPixels reached line %d\n", 983);
1149
1150		✗	int32_t* pos = &v[0];
1151		✗	int32_t sz = v.size();
1152			//Z_scripterrlog("Vector size is: %d\n", sz);
1153			//for ( int32_t m = 0; m < 256; ++m ) Z_scripterrlog("Vector contents at pos[%d]: %d\n", m, pos[m]);
1154
1155			//FFCore.getValues(sdci[2]/10000, points, sz);
1156
1157
1158		✗	int32_t x1 = 0;
1159		✗	int32_t y1 = 0;
1160
1161		✗	for ( int32_t q = 0; q < sz; q+=4 )
1162			{
1163			//Z_scripterrlog("Vector q: %d\n", q);
1164			//if ( q > sz-1 ) break;
1165		✗	x1 = v.at(q); //pos[q];
1166		✗	y1 = v.at(q+1); //pos[q+1];
1167			//Z_scripterrlog("x1 is: %d\n", x1);
1168			//Z_scripterrlog("y1 is: %d\n", 1);
1169		✗	if(sdci[5]!=0) //rotation
1170			{
1171			int32_t xy[2];
1172		✗	int32_t rx=sdci[3]/10000;
1173		✗	int32_t ry=sdci[4]/10000;
1174		✗	fixed ra1=itofix(sdci[5]%10000)/10000;
1175		✗	fixed ra2=itofix(sdci[5]/10000);
1176		✗	fixed ra=ra1+ra2;
1177
1178		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1179		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1180		✗	x1=xy[0];
1181		✗	y1=xy[1];
1182			}
1183			//Z_scripterrlog("PutPixels()%s value is %d\n","x",x1);
1184			//Z_scripterrlog("PutPixels()%s value is %d\n","y",y1);
1185			//Z_scripterrlog("PutPixels()%s value is %d\n","colour",points[q+2]);
1186		✗	if ( v.at(q+3) /*pos[q+3]*/ < 128 ) drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1187		✗	else drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1188		✗	putpixel(bmp, x1+xoffset, y1+yoffset, v.at(q+2) /*pos[q+2]*/);
1189			//if ( points[q+3] < 128 )
1190
1191			//else drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
1192			}
1193		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
1194			}
1195
1196		✗	void do_drawtiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1197			{
1198			//sdci[1]=layer
1199			//sdci[2]=x
1200			//sdci[3]=y
1201			//sdci[4]=tile
1202			//sdci[5]=tile width
1203			//sdci[6]=tile height
1204			//sdci[7]=color (cset)
1205			//sdci[8]=scale x
1206			//sdci[9]=scale y
1207			//sdci[10]=rotation anchor x
1208			//sdci[11]=rotation anchor y
1209			//sdci[12]=rotation angle
1210			//sdci[13]=flip
1211			//sdci[14]=transparency
1212			//sdci[15]=opacity
1213
1214		✗	int32_t w = sdci[5]/10000;
1215		✗	int32_t h = sdci[6]/10000;
1216
1217		✗	if(w < 1 || h < 1 || h > 20 || w > 20)
1218			{
1219		✗	return;
1220			}
1221
1222		✗	int32_t xscale=sdci[8]/10000;
1223		✗	int32_t yscale=sdci[9]/10000;
1224		✗	int32_t rx = sdci[10]/10000;
1225		✗	int32_t ry = sdci[11]/10000;
1226		✗	float rotation=sdci[12]/10000;
1227		✗	int32_t flip=(sdci[13]/10000)&3;
1228		✗	bool transparency=sdci[14]!=0;
1229		✗	int32_t opacity=sdci[15]/10000;
1230		✗	int32_t color=sdci[7]/10000;
1231
1232		✗	int32_t x1=sdci[2]/10000;
1233		✗	int32_t y1=sdci[3]/10000;
1234
1235			//don't scale if it's not safe to do so
1236		✗	bool canscale = true;
1237
1238		✗	if(xscale==0||yscale==0)
1239			{
1240		✗	return;
1241			}
1242
1243		✗	if(xscale<0||yscale<0)
1244		✗	canscale = false; //default size
1245
1246		✗	if((xscale>0 && yscale>0) || rotation) //scaled or rotated
1247			{
1248		✗	BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16);
1249
1250		✗	if(transparency) //transparency
1251			{
1252		✗	TileHelper::OverTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
1253			}
1254			else //no transparency
1255			{
1256		✗	TileHelper::OldPutTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
1257			}
1258
1259		✗	if(rotation != 0)
1260			{
1261			//low negative values indicate no anchor-point rotation
1262		✗	if(rx>-777||ry>-777)
1263			{
1264			int32_t xy[2];
1265		✗	fixed ra1=itofix(sdci[12]%10000)/10000;
1266		✗	fixed ra2=itofix(sdci[12]/10000);
1267		✗	fixed ra=ra1+ra2;
1268		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1269		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1270		✗	x1=xy[0];
1271		✗	y1=xy[1];
1272			}
1273
1274		✗	if(canscale) //scale first
1275			{
1276			//damnit all, .. fixme.
1277		✗	BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
1278		✗	clear_bitmap(tempbit);
1279
1280		✗	stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
1281
1282		✗	if(opacity < 128)
1283			{
1284		✗	clear_bitmap(prim_bmp);
1285		✗	rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
1286		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1287			}
1288			else
1289			{
1290		✗	rotate_sprite(bmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1291			}
1292
1293		✗	destroy_bitmap(tempbit);
1294			}
1295			else //no scale
1296			{
1297		✗	if(opacity < 128)
1298			{
1299		✗	clear_bitmap(prim_bmp);
1300		✗	rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
1301		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1302			}
1303			else
1304			{
1305		✗	rotate_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1306			}
1307			}
1308			}
1309			else //scale only
1310			{
1311		✗	if(canscale)
1312			{
1313		✗	if(opacity<128)
1314			{
1315		✗	clear_bitmap(prim_bmp);
1316		✗	stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
1317		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1318			}
1319			else
1320			{
1321		✗	stretch_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
1322			}
1323			}
1324			else //error -do not scale
1325			{
1326		✗	if(opacity<128)
1327			{
1328		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1329			}
1330			else
1331			{
1332		✗	draw_sprite(bmp, pbitty, x1+xoffset, y1+yoffset);
1333			}
1334			}
1335			}
1336
1337		✗	script_drawing_commands.ReleaseSubBitmap(pbitty);
1338
1339			}
1340			else // no scale or rotation
1341			{
1342		✗	if(transparency)
1343			{
1344		✗	if(opacity<=127)
1345		✗	TileHelper::OverTileTranslucent(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
1346			else
1347		✗	TileHelper::OverTile(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
1348			}
1349			else
1350			{
1351		✗	if(opacity<=127)
1352		✗	TileHelper::PutTileTranslucent(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
1353			else
1354		✗	TileHelper::OldPutTile(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
1355			}
1356			}
1357			}
1358
1359		✗	void do_drawtilecloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1360			{
1361			//sdci[1]=layer
1362			//sdci[2]=x
1363			//sdci[3]=y
1364			//sdci[4]=tile
1365			//sdci[5]=tile width
1366			//sdci[6]=tile height
1367			//sdci[7]=flip
1368
1369		✗	int32_t w = sdci[5]/10000;
1370		✗	int32_t h = sdci[6]/10000;
1371
1372		✗	if(w < 1 || h < 1 || h > 20 || w > 20)
1373			{
1374		✗	return;
1375			}
1376
1377		✗	int32_t flip=(sdci[7]/10000)&3;
1378
1379		✗	int32_t x1=sdci[2]/10000;
1380		✗	int32_t y1=sdci[3]/10000;
1381
1382		✗	TileHelper::OverTileCloaked(bmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, flip);
1383			}
1384
1385
1386		✗	void do_drawcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1387			{
1388			//sdci[1]=layer
1389			//sdci[2]=x
1390			//sdci[3]=y
1391			//sdci[4]=combo
1392			//sdci[5]=tile width
1393			//sdci[6]=tile height
1394			//sdci[7]=color (cset)
1395			//sdci[8]=scale x
1396			//sdci[9]=scale y
1397			//sdci[10]=rotation anchor x
1398			//sdci[11]=rotation anchor y
1399			//sdci[12]=rotation angle
1400			//sdci[13]=frame
1401			//sdci[14]=flip
1402			//sdci[15]=transparency
1403			//sdci[16]=opacity
1404
1405		✗	int32_t w = sdci[5]/10000;
1406		✗	int32_t h = sdci[6]/10000;
1407
1408		✗	if(w<1||h<1||h>20||w>20)
1409			{
1410		✗	return;
1411			}
1412		✗	int32_t cmb = (sdci[4]/10000);
1413		✗	if((unsigned)cmb >= MAXCOMBOS)
1414			{
1415		✗	Z_scripterrlog("DrawCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
1416		✗	return;
1417			}
1418
1419		✗	int32_t xscale=sdci[8]/10000;
1420		✗	int32_t yscale=sdci[9]/10000;
1421		✗	int32_t rx = sdci[10]/10000; //these work now
1422		✗	int32_t ry = sdci[11]/10000; //these work now
1423		✗	float rotation=sdci[12]/10000;
1424
1425		✗	bool transparency=sdci[15]!=0;
1426		✗	int32_t opacity=sdci[16]/10000;
1427		✗	int32_t color=sdci[7]/10000;
1428		✗	int32_t x1=sdci[2]/10000;
1429		✗	int32_t y1=sdci[3]/10000;
1430
1431		✗	const newcombo & c = combobuf[cmb];
1432		✗	int32_t tiletodraw = combo_tile(c, x1, y1);
1433		✗	int32_t flip = ((sdci[14]/10000) & 3) ^ c.flip;
1434		✗	int32_t skiprows=c.skipanimy;
1435
1436
1437			//don't scale if it's not safe to do so
1438		✗	bool canscale = true;
1439
1440		✗	if(xscale==0||yscale==0)
1441			{
1442		✗	return;
1443			}
1444
1445		✗	if(xscale<0||yscale<0)
1446		✗	canscale = false; //default size
1447
1448		✗	if((xscale>0 && yscale>0) || rotation) //scaled or rotated
1449			{
1450		✗	BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16); //-pbitty in the hisouse. :D
1451
1452		✗	if(transparency)
1453			{
1454		✗	TileHelper::OverTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
1455			}
1456			else //no transparency
1457			{
1458		✗	TileHelper::OldPutTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
1459			}
1460
1461		✗	if(rotation != 0) // rotate
1462			{
1463			//fixed point sucks ;0
1464		✗	if(rx>-777||ry>-777) //set the rotation anchor and rotate around that
1465			{
1466			int32_t xy[2];
1467		✗	fixed ra1=itofix(sdci[12]%10000)/10000;
1468		✗	fixed ra2=itofix(sdci[12]/10000);
1469		✗	fixed ra=ra1+ra2;
1470		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
1471		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
1472		✗	x1=xy[0];
1473		✗	y1=xy[1];
1474			}
1475
1476		✗	if(canscale) //scale first
1477			{
1478		✗	BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
1479		✗	clear_bitmap(tempbit);
1480
1481		✗	stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
1482
1483		✗	if(opacity < 128)
1484			{
1485		✗	clear_bitmap(prim_bmp);
1486		✗	rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
1487		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1488			}
1489			else
1490			{
1491		✗	rotate_sprite(bmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1492			}
1493
1494		✗	destroy_bitmap(tempbit);
1495			}
1496			else //no scale
1497			{
1498		✗	if(opacity < 128)
1499			{
1500		✗	clear_bitmap(prim_bmp);
1501		✗	rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
1502		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1503			}
1504			else
1505			{
1506		✗	rotate_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
1507			}
1508			}
1509			}
1510			else //scale only
1511			{
1512		✗	if(canscale)
1513			{
1514		✗	if(opacity<128)
1515			{
1516		✗	clear_bitmap(prim_bmp);
1517		✗	stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
1518		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1519			}
1520			else
1521			{
1522		✗	stretch_sprite(bmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
1523			}
1524			}
1525			else //error -do not scale
1526			{
1527		✗	if(opacity<128)
1528			{
1529		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
1530			}
1531			else
1532			{
1533		✗	draw_sprite(bmp, pbitty, x1+xoffset, y1+yoffset);
1534			}
1535			}
1536			}
1537
1538		✗	script_drawing_commands.ReleaseSubBitmap(pbitty); //rap sucks
1539			}
1540			else // no scale or rotation
1541			{
1542		✗	if(transparency)
1543			{
1544		✗	if(opacity<=127)
1545		✗	TileHelper::OverTileTranslucent(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
1546			else
1547		✗	TileHelper::OverTile(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
1548			}
1549			else
1550			{
1551		✗	if(opacity<=127)
1552		✗	TileHelper::PutTileTranslucent(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
1553			else
1554		✗	TileHelper::OldPutTile(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
1555			}
1556			}
1557			}
1558
1559		✗	void do_drawcombocloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1560			{
1561			//sdci[1]=layer
1562			//sdci[2]=x
1563			//sdci[3]=y
1564			//sdci[4]=combo
1565			//sdci[5]=tile width
1566			//sdci[6]=tile height
1567			//sdci[7]=flip
1568
1569		✗	int32_t w = sdci[5]/10000;
1570		✗	int32_t h = sdci[6]/10000;
1571
1572		✗	if(w<1||h<1||h>20||w>20)
1573			{
1574		✗	return;
1575			}
1576		✗	int32_t cmb = (sdci[4]/10000);
1577		✗	if((unsigned)cmb >= MAXCOMBOS)
1578			{
1579		✗	Z_scripterrlog("DrawComboCloaked() cannot draw combo '%d', as it is out of bounds.\n", cmb);
1580		✗	return;
1581			}
1582
1583		✗	int32_t x1=sdci[2]/10000;
1584		✗	int32_t y1=sdci[3]/10000;
1585
1586		✗	const newcombo & c = combobuf[cmb];
1587		✗	int32_t tiletodraw = combo_tile(c, x1, y1);
1588		✗	int32_t flip = ((sdci[7]/10000) & 3) ^ c.flip;
1589		✗	int32_t skiprows=c.skipanimy;
1590
1591		✗	TileHelper::OverTileCloaked(bmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, flip, skiprows);
1592			}
1593
1594
1595		✗	void do_fasttiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1596			{
1597			/* layer, x, y, tile, color opacity */
1598
1599		✗	int32_t opacity = sdci[6]/10000;
1600
1601		✗	if(opacity < 128)
1602		✗	overtiletranslucent16(bmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0, opacity);
1603			else
1604		✗	overtile16(bmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0);
1605			}
1606
1607		✗	void do_fasttilesr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1608			{
1609			/* layer, x, y, tile, color opacity */
1610
1611			//sdci[1]=layer
1612			//sdci[2]=array {x,y,tile,colour,opacity}
1613
1614		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1615
1616		✗	if(!v_ptr)
1617			{
1618		✗	al_trace("Screen->PutPixels: Vector pointer is null! Internal error. \n");
1619		✗	return;
1620			}
1621
1622		✗	std::vector<int32_t> &v = *v_ptr;
1623
1624		✗	if(v.empty())
1625		✗	return;
1626			//Z_scripterrlog("PutPixels reached line %d\n", 983);
1627
1628		✗	int32_t* pos = &v[0];
1629		✗	int32_t sz = v.size();
1630
1631		✗	for ( int32_t q = 0; q < sz; q+=5 )
1632			{
1633
1634		✗	if(v.at(q+4) < 128)
1635		✗	overtiletranslucent16(bmp, v.at(q), xoffset+(v.at(q+1)), yoffset+(v.at(q+2)), v.at(q+3), 0, v.at(q+4));
1636			else
1637		✗	overtile16(bmp, v.at(q), xoffset+(v.at(q+1)), yoffset+(v.at(q+2)), v.at(q+3), 0);
1638			}
1639			}
1640
1641
1642
1643		✗	void do_fastcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1644			{
1645			/* layer, x, y, tile, color opacity */
1646
1647		✗	int32_t opacity = sdci[6] / 10000;
1648		✗	int32_t x1 = sdci[2] / 10000;
1649		✗	int32_t y1 = sdci[3] / 10000;
1650
1651		✗	int32_t cmb = (sdci[4]/10000);
1652		✗	if((unsigned)cmb >= MAXCOMBOS)
1653			{
1654		✗	Z_scripterrlog("FastCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
1655		✗	return;
1656			}
1657			//if( index >= MAXCOMBOS ) return; //bleh.
1658			/*
1659			const newcombo & c = combobuf[index];
1660
1661			if(opacity < 128)
1662			overtiletranslucent16(bmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip, opacity);
1663			else
1664			overtile16(bmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip);
1665			*/
1666
1667		✗	if(opacity < 128)
1668			{
1669			//void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
1670		✗	overcomboblocktranslucent(bmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1, 128);
1671
1672			}
1673			else
1674			{
1675			//overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
1676		✗	overcomboblock(bmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1);
1677			}
1678			}
1679
1680		✗	void do_fastcombosr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1681			{
1682			/* layer, x, y, combo, cset, opacity */
1683
1684			//sdci[1]=layer
1685			//sdci[2]=array {x,y,combo,cset,opacity}
1686
1687		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
1688
1689		✗	if(!v_ptr)
1690			{
1691		✗	al_trace("Screen->FastCombos: Vector pointer is null! Internal error. \n");
1692		✗	return;
1693			}
1694
1695		✗	std::vector<int32_t> &v = *v_ptr;
1696
1697		✗	if(v.empty())
1698		✗	return;
1699
1700		✗	int32_t* pos = &v[0];
1701		✗	int32_t sz = v.size();
1702
1703		✗	for ( int32_t q = 0; q < sz; q+=5 )
1704			{
1705		✗	if((unsigned)(v.at(q+2)) >= MAXCOMBOS)
1706			{
1707		✗	Z_scripterrlog("FastCombos() cannot draw combo '%d', as it is out of bounds.\n", v.at(q+2));
1708		✗	continue;
1709			}
1710		✗	if(v.at(q+4) < 128)
1711			{
1712			//void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
1713		✗	overcomboblocktranslucent(bmp, xoffset+v.at(q), yoffset+v.at(q+1), v.at(q+2), v.at(q+3), 1, 1, 128);
1714
1715			}
1716			else
1717			{
1718			//overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
1719		✗	overcomboblock(bmp, xoffset+v.at(q), yoffset+v.at(q+1), v.at(q+2), v.at(q+3), 1, 1);
1720			}
1721			}
1722			}
1723
1724
1725
1726
1727		✗	void do_drawcharr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1728			{
1729			//broken 2.50.2 and earlier drawcharacter()
1730		✗	if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
1731			{
1732			//sdci[1]=layer
1733			//sdci[2]=x
1734			//sdci[3]=y
1735			//sdci[4]=font
1736			//sdci[5]=color
1737			//sdci[6]=bg color
1738			//sdci[7]=strech x (width)
1739			//sdci[8]=stretch y (height)
1740			//sdci[9]=char
1741			//sdci[10]=opacity
1742
1743		✗	int32_t x=sdci[2]/10000;
1744		✗	int32_t y=sdci[3]/10000;
1745		✗	int32_t font_index=sdci[4]/10000;
1746		✗	int32_t color=sdci[5]/10000;
1747		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
1748		✗	int32_t w=sdci[7]/10000;
1749		✗	int32_t h=sdci[8]/10000;
1750		✗	char glyph=char(sdci[9]/10000);
1751		✗	int32_t opacity=sdci[10]/10000;
1752
1753			//safe check
1754		✗	if(bg_color < -1) bg_color = -1;
1755
1756		✗	if(w>512) w=512; //w=vbound(w,0,512);
1757
1758		✗	if(h>512) h=512; //h=vbound(h,0,512);
1759
1760			//undone
1761		✗	if(w>0&&h>0)//stretch the character
1762			{
1763		✗	BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
1764
1765		✗	if(opacity < 128)
1766			{
1767		✗	if(w>128||h>128)
1768			{
1769		✗	clear_bitmap(prim_bmp);
1770
1771		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1772		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
1773		✗	draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
1774			}
1775			else //this is faster
1776			{
1777		✗	BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
1778
1779		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1780		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
1781		✗	draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
1782
1783		✗	script_drawing_commands.ReleaseSubBitmap(pbmp2);
1784			}
1785			}
1786			else // no opacity
1787			{
1788		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1789		✗	stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
1790			}
1791
1792			}
1793			else //no stretch
1794			{
1795		✗	if(opacity < 128)
1796			{
1797		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
1798		✗	clear_bitmap(pbmp);
1799
1800		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1801		✗	draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
1802
1803		✗	destroy_bitmap(pbmp);
1804			}
1805			else // no opacity
1806			{
1807		✗	textprintf_ex(bmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
1808			}
1809			}
1810			}
1811
1812			else //2.53.0 fixed version and later.
1813			{
1814
1815			//sdci[1]=layer
1816			//sdci[2]=x
1817			//sdci[3]=y
1818			//sdci[4]=font
1819			//sdci[5]=color
1820			//sdci[6]=bg color
1821			//sdci[7]=strech x (width)
1822			//sdci[8]=stretch y (height)
1823			//sdci[9]=char
1824			//sdci[10]=opacity
1825
1826		✗	int32_t x=sdci[2]/10000;
1827		✗	int32_t y=sdci[3]/10000;
1828		✗	int32_t font_index=sdci[4]/10000;
1829		✗	int32_t color=sdci[5]/10000;
1830		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
1831		✗	int32_t w=sdci[7]/10000;
1832		✗	int32_t h=sdci[8]/10000;
1833		✗	char glyph=char(sdci[9]/10000);
1834		✗	int32_t opacity=sdci[10]/10000;
1835
1836			//safe check
1837		✗	if(bg_color < -1) bg_color = -1;
1838
1839		✗	if(w>512) w=512; //w=vbound(w,0,512);
1840
1841		✗	if(h>512) h=512; //h=vbound(h,0,512);
1842
1843			//undone
1844		✗	if(w>0&&h>0)//stretch the character
1845			{
1846		✗	BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
1847
1848		✗	if(opacity < 128)
1849			{
1850		✗	if(w>128||h>128)
1851			{
1852		✗	clear_bitmap(prim_bmp);
1853
1854		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1855		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
1856		✗	draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
1857			}
1858			else //this is faster
1859			{
1860		✗	BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
1861
1862		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1863		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
1864		✗	draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
1865
1866		✗	script_drawing_commands.ReleaseSubBitmap(pbmp2);
1867			}
1868			}
1869			else // no opacity
1870			{
1871		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1872		✗	stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
1873			}
1874
1875			}
1876			else //no stretch
1877			{
1878		✗	if(opacity < 128)
1879			{
1880		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
1881		✗	clear_bitmap(pbmp);
1882
1883		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
1884		✗	draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
1885
1886		✗	destroy_bitmap(pbmp);
1887			}
1888			else // no opacity
1889			{
1890		✗	textprintf_ex(bmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
1891			}
1892			}
1893
1894			}
1895
1896			}
1897
1898
1899		✗	void do_drawintr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
1900			{
1901			//broken 2.50.2 and earlier drawinteger()
1902		✗	if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
1903			{
1904			//sdci[1]=layer
1905			//sdci[2]=x
1906			//sdci[3]=y
1907			//sdci[4]=font
1908			//sdci[5]=color
1909			//sdci[6]=bg color
1910			//sdci[7]=strech x (width)
1911			//sdci[8]=stretch y (height)
1912			//sdci[9]=integer
1913			//sdci[10]=num decimal places
1914			//sdci[11]=opacity
1915
1916		✗	int32_t x=sdci[2]/10000;
1917		✗	int32_t y=sdci[3]/10000;
1918		✗	int32_t font_index=sdci[4]/10000;
1919		✗	int32_t color=sdci[5]/10000;
1920		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
1921		✗	int32_t w=sdci[7]/10000;
1922		✗	int32_t h=sdci[8]/10000;
1923			//float number=static_cast<float>(sdci[9])/10000.0f;
1924		✗	int32_t decplace=sdci[10]/10000;
1925		✗	int32_t opacity=sdci[11]/10000;
1926
1927			//safe check
1928		✗	if(bg_color < -1) bg_color = -1;
1929
1930		✗	if(w>512) w=512; //w=vbound(w,0,512);
1931
1932		✗	if(h>512) h=512; //h=vbound(h,0,512);
1933
1934			char numbuf[15];
1935
1936		✗	switch(decplace)
1937			{
1938			default:
1939			case 0:
1940		✗	sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
1941		✗	break; //reducing the value by -1, so 8.000 printed as '7'. -Z
1942
1943			case 1:
1944			//sprintf(numbuf,"%.01f",number);
1945		✗	sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
1946		✗	break;
1947
1948			case 2:
1949			//sprintf(numbuf,"%.02f",number);
1950		✗	sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
1951		✗	break;
1952
1953			case 3:
1954			//sprintf(numbuf,"%.03f",number);
1955		✗	sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
1956		✗	break;
1957
1958			case 4:
1959			//sprintf(numbuf,"%.04f",number);
1960		✗	sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
1961		✗	break;
1962			}
1963
1964		✗	if(w>0&&h>0)//stretch
1965			{
1966		✗	BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
1967
1968		✗	if(opacity < 128)
1969			{
1970		✗	if(w>128||h>128)
1971			{
1972		✗	clear_bitmap(prim_bmp);
1973
1974		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
1975		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
1976		✗	draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
1977			}
1978			else
1979			{
1980		✗	BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
1981		✗	clear_bitmap(pbmp2);
1982
1983		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
1984		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
1985		✗	draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
1986
1987		✗	destroy_bitmap(pbmp2);
1988			}
1989			}
1990			else // no opacity
1991			{
1992		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
1993		✗	stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
1994			}
1995
1996			}
1997			else //no stretch
1998			{
1999		✗	if(opacity < 128)
2000			{
2001		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
2002		✗	clear_bitmap(pbmp);
2003
2004		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2005		✗	draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2006
2007		✗	destroy_bitmap(pbmp);
2008			}
2009			else // no opacity
2010			{
2011		✗	textout_ex(bmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
2012			}
2013			}
2014
2015			}
2016
2017			else //2.53.0 fixed version and later.
2018			{
2019			//sdci[1]=layer
2020			//sdci[2]=x
2021			//sdci[3]=y
2022			//sdci[4]=font
2023			//sdci[5]=color
2024			//sdci[6]=bg color
2025			//sdci[7]=strech x (width)
2026			//sdci[8]=stretch y (height)
2027			//sdci[9]=integer
2028			//sdci[10]=num decimal places
2029			//sdci[11]=opacity
2030
2031		✗	int32_t x=sdci[2]/10000;
2032		✗	int32_t y=sdci[3]/10000;
2033		✗	int32_t font_index=sdci[4]/10000;
2034		✗	int32_t color=sdci[5]/10000;
2035		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
2036		✗	int32_t w=sdci[7]/10000;
2037		✗	int32_t h=sdci[8]/10000;
2038			//float number=static_cast<float>(sdci[9])/10000.0f;
2039			//int32_t numberint = sdci[9]/10000;
2040		✗	int32_t decplace=sdci[10]/10000;
2041		✗	int32_t opacity=sdci[11]/10000;
2042
2043			//safe check
2044		✗	if(bg_color < -1) bg_color = -1;
2045
2046		✗	if(w>512) w=512; //w=vbound(w,0,512);
2047
2048		✗	if(h>512) h=512; //h=vbound(h,0,512);
2049
2050			char numbuf[15];
2051
2052		✗	switch(decplace)
2053			{
2054			default:
2055			case 0:
2056		✗	sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
2057		✗	break; //reducing the value by -1, so 8.000 printed as '7'. -Z
2058
2059			case 1:
2060			//sprintf(numbuf,"%.01f",number);
2061		✗	sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
2062		✗	break;
2063
2064			case 2:
2065			//sprintf(numbuf,"%.02f",number);
2066		✗	sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
2067		✗	break;
2068
2069			case 3:
2070			//sprintf(numbuf,"%.03f",number);
2071		✗	sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
2072		✗	break;
2073
2074			case 4:
2075			//sprintf(numbuf,"%.04f",number);
2076		✗	sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
2077		✗	break;
2078			}
2079
2080			//FONT* font=get_zc_font(sdci[4]/10000);
2081
2082		✗	if(w>0&&h>0)//stretch
2083			{
2084		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(get_zc_font(font_index), numbuf)+1, text_height(get_zc_font(font_index)));
2085		✗	clear_bitmap(pbmp);
2086			//script_drawing_commands.GetSmallTextureBitmap(1,1);
2087
2088		✗	if(opacity < 128)
2089			{
2090		✗	if(w>128||h>128)
2091			{
2092		✗	clear_bitmap(prim_bmp);
2093
2094		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2095		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
2096		✗	draw_trans_sprite(bmp, prim_bmp, x+xoffset, y+yoffset);
2097			}
2098			else
2099			{
2100		✗	BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
2101		✗	clear_bitmap(pbmp2);
2102
2103		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2104		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
2105		✗	draw_trans_sprite(bmp, pbmp2, x+xoffset, y+yoffset);
2106
2107		✗	destroy_bitmap(pbmp2);
2108			}
2109			}
2110			else // no opacity
2111			{
2112		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
2113		✗	stretch_sprite(bmp, pbmp, x+xoffset, y+yoffset, w, h);
2114			}
2115
2116			}
2117			else //no stretch
2118			{
2119		✗	if(opacity < 128)
2120			{
2121		✗	FONT* font = get_zc_font(font_index);
2122		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(font, numbuf), text_height(font));
2123		✗	clear_bitmap(pbmp);
2124
2125		✗	textout_ex(pbmp, font, numbuf, 0, 0, color, bg_color);
2126		✗	draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2127
2128		✗	destroy_bitmap(pbmp);
2129			}
2130			else // no opacity
2131			{
2132		✗	textout_ex(bmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
2133			}
2134			}
2135			}
2136			}
2137
2138
2139		✗	void do_drawstringr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2140			{
2141			//sdci[1]=layer
2142			//sdci[2]=x
2143			//sdci[3]=y
2144			//sdci[4]=font
2145			//sdci[5]=color
2146			//sdci[6]=bg color
2147			//sdci[7]=format_option
2148			//sdci[8]=string
2149			//sdci[9]=opacity
2150
2151		✗	std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
2152
2153		✗	if(!str)
2154			{
2155		✗	al_trace("String pointer is null! Internal error. \n");
2156		✗	return;
2157			}
2158
2159		✗	int32_t x=sdci[2]/10000;
2160		✗	int32_t y=sdci[3]/10000;
2161		✗	FONT* font=get_zc_font(sdci[4]/10000);
2162		✗	int32_t color=sdci[5]/10000;
2163		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
2164		✗	int32_t format_type=sdci[7]/10000;
2165		✗	int32_t opacity=sdci[9]/10000;
2166			//sdci[8] not needed :)
2167
2168			//safe check
2169		✗	if(bg_color < -1) bg_color = -1;
2170
2171		✗	if(opacity < 128)
2172			{
2173		✗	int32_t width=zc_min(text_length(font, str->c_str()), 512);
2174		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
2175		✗	clear_bitmap(pbmp);
2176		✗	textout_ex(pbmp, font, str->c_str(), 0, 0, color, bg_color);
2177		✗	if(format_type == 2) // right-sided text
2178		✗	x-=width;
2179		✗	else if(format_type == 1) // centered text
2180		✗	x-=width/2;
2181		✗	draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2182		✗	destroy_bitmap(pbmp);
2183			}
2184			else // no opacity
2185			{
2186		✗	if(format_type == 2) // right-sided text
2187			{
2188		✗	textout_right_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
2189			}
2190		✗	else if(format_type == 1) // centered text
2191			{
2192		✗	textout_centre_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
2193			}
2194			else // standard left-sided text
2195			{
2196		✗	textout_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
2197			}
2198			}
2199			}
2200
2201		✗	void do_drawstringr2(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2202			{
2203			//sdci[1]=layer
2204			//sdci[2]=x
2205			//sdci[3]=y
2206			//sdci[4]=font
2207			//sdci[5]=color
2208			//sdci[6]=bg color
2209			//sdci[7]=format_option
2210			//sdci[8]=string
2211			//sdci[9]=opacity
2212			//sdci[10]=shadowtype
2213			//sdci[11]=shadow_color
2214
2215		✗	std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
2216
2217		✗	if(!str)
2218			{
2219		✗	al_trace("String pointer is null! Internal error. \n");
2220		✗	return;
2221			}
2222
2223		✗	int32_t x=sdci[2]/10000;
2224		✗	int32_t y=sdci[3]/10000;
2225		✗	FONT* font=get_zc_font(sdci[4]/10000);
2226		✗	int32_t color=sdci[5]/10000;
2227		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
2228		✗	int32_t format_type=sdci[7]/10000;
2229		✗	int32_t opacity=sdci[9]/10000;
2230		✗	int32_t textstyle = sdci[10]/10000;
2231		✗	int32_t shadow_color = sdci[11]/10000;
2232			//sdci[8] not needed :)
2233
2234			//safe check
2235		✗	if(bg_color < -1) bg_color = -1;
2236
2237		✗	if(opacity < 128)
2238			{
2239		✗	int32_t width=zc_min(text_length(font, str->c_str()), 512);
2240		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
2241		✗	clear_bitmap(pbmp);
2242		✗	textout_styled_aligned_ex(pbmp, font, str->c_str(), 0, 0, textstyle, sstaLEFT, color, shadow_color, bg_color);
2243		✗	textout_ex(pbmp, font, str->c_str(), 0, 0, color, bg_color);
2244		✗	if(format_type == 2) // right-sided text
2245		✗	x-=width;
2246		✗	else if(format_type == 1) // centered text
2247		✗	x-=width/2;
2248		✗	draw_trans_sprite(bmp, pbmp, x+xoffset, y+yoffset);
2249		✗	destroy_bitmap(pbmp);
2250			}
2251			else // no opacity
2252			{
2253		✗	textout_styled_aligned_ex(bmp, font, str->c_str(), x+xoffset, y+yoffset, textstyle, format_type, color, shadow_color, bg_color);
2254			}
2255			}
2256
2257
2258		✗	void do_drawquadr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2259			{
2260			//sdci[1]=layer
2261			//sdci[2]=x1
2262			//sdci[3]=y1
2263			//sdci[4]=x2
2264			//sdci[5]=y2
2265			//sdci[6]=x3
2266			//sdci[7]=y3
2267			//sdci[8]=x4
2268			//sdci[9]=y4
2269			//sdci[10]=width
2270			//sdci[11]=height
2271			//sdci[12]=cset
2272			//sdci[13]=flip
2273			//sdci[14]=tile/combo
2274			//sdci[15]=polytype
2275
2276		✗	int32_t x1 = sdci[2]/10000;
2277		✗	int32_t y1 = sdci[3]/10000;
2278		✗	int32_t x2 = sdci[4]/10000;
2279		✗	int32_t y2 = sdci[5]/10000;
2280		✗	int32_t x3 = sdci[6]/10000;
2281		✗	int32_t y3 = sdci[7]/10000;
2282		✗	int32_t x4 = sdci[8]/10000;
2283		✗	int32_t y4 = sdci[9]/10000;
2284		✗	int32_t w = sdci[10]/10000;
2285		✗	int32_t h = sdci[11]/10000;
2286		✗	int32_t color = sdci[12]/10000;
2287		✗	int32_t flip=(sdci[13]/10000)&3;
2288		✗	int32_t tile = sdci[14]/10000;
2289		✗	int32_t polytype = sdci[15]/10000;
2290
2291			//todo: finish palette shading
2292			/*
2293			POLYTYPE_FLAT
2294			POLYTYPE_GCOL
2295			POLYTYPE_GRGB
2296			POLYTYPE_ATEX
2297			POLYTYPE_PTEX
2298			POLYTYPE_ATEX_MASK
2299			POLYTYPE_PTEX_MASK
2300			POLYTYPE_ATEX_LIT
2301			POLYTYPE_PTEX_LIT
2302			POLYTYPE_ATEX_MASK_LIT
2303			POLYTYPE_PTEX_MASK_LIT
2304			POLYTYPE_ATEX_TRANS
2305			POLYTYPE_PTEX_TRANS
2306			POLYTYPE_ATEX_MASK_TRANS
2307			POLYTYPE_PTEX_MASK_TRANS
2308			*/
2309		✗	polytype = vbound(polytype, 0, 14);
2310
2311		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
2312			{
2313		✗	Z_message("Quad() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
2314		✗	return; //non power of two error
2315			}
2316
2317		✗	int32_t tex_width = w*16;
2318		✗	int32_t tex_height = h*16;
2319
2320			BITMAP *tex;
2321
2322		✗	bool mustDestroyBmp = false;
2323
2324		✗	if ( tile > 65519 ) tex = zscriptDrawingRenderTarget->GetBitmapPtr(tile - 65519);
2325		✗	else tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
2326
2327		✗	if(!tex)
2328			{
2329		✗	mustDestroyBmp = true;
2330		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
2331		✗	clear_bitmap(tex);
2332			}
2333
2334			int32_t col[4];
2335			/*
2336			if( color < 0 )
2337			{
2338			col[0]=draw_container.color_buffer[0];
2339			col[1]=draw_container.color_buffer[1];
2340			col[2]=draw_container.color_buffer[2];
2341			col[3]=draw_container.color_buffer[3];
2342			}
2343			else */
2344			{
2345		✗	col[0]=col[1]=col[2]=col[3]=color;
2346			}
2347
2348		✗	if(tile > 0 && tile <= 65519) // TILE
2349			{
2350		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
2351			}
2352
2353		✗	if ( tile < 0 ) // COMBO
2354			{
2355		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
2356		✗	const int32_t tiletodraw = combo_tile(c, x1, y1);
2357		✗	flip = flip ^ c.flip;
2358
2359		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
2360			}
2361
2362		✗	V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
2363		✗	V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(tex_height), col[1] };
2364		✗	V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(tex_width), static_cast<float>(tex_height), col[2] };
2365		✗	V3D_f V4 = { static_cast<float>(x4+xoffset), static_cast<float>(y4+yoffset), 0, static_cast<float>(tex_width), 0, col[3] };
2366
2367		✗	quad3d_f(bmp, polytype, tex, &V1, &V2, &V3, &V4);
2368
2369		✗	if(mustDestroyBmp)
2370		✗	destroy_bitmap(tex);
2371
2372			}
2373
2374
2375		✗	void do_drawtriangler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2376			{
2377			//sdci[1]=layer
2378			//sdci[2]=x1
2379			//sdci[3]=y1
2380			//sdci[4]=x2
2381			//sdci[5]=y2
2382			//sdci[6]=x3
2383			//sdci[7]=y3
2384			//sdci[8]=width
2385			//sdci[9]=height
2386			//sdci[10]=cset
2387			//sdci[11]=flip
2388			//sdci[12]=tile/combo
2389			//sdci[13]=polytype
2390
2391		✗	int32_t x1 = sdci[2]/10000;
2392		✗	int32_t y1 = sdci[3]/10000;
2393		✗	int32_t x2 = sdci[4]/10000;
2394		✗	int32_t y2 = sdci[5]/10000;
2395		✗	int32_t x3 = sdci[6]/10000;
2396		✗	int32_t y3 = sdci[7]/10000;
2397		✗	int32_t w = sdci[8]/10000;
2398		✗	int32_t h = sdci[9]/10000;
2399		✗	int32_t color = sdci[10]/10000;
2400		✗	int32_t flip=(sdci[11]/10000)&3;
2401		✗	int32_t tile = sdci[12]/10000;
2402		✗	int32_t polytype = sdci[13]/10000;
2403
2404		✗	polytype = vbound(polytype, 0, 14);
2405
2406		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
2407			{
2408		✗	Z_message("Quad() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
2409		✗	return; //non power of two error
2410			}
2411
2412		✗	int32_t tex_width = w*16;
2413		✗	int32_t tex_height = h*16;
2414
2415		✗	bool mustDestroyBmp = false;
2416		✗	BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
2417
2418		✗	if(!tex)
2419			{
2420		✗	mustDestroyBmp = true;
2421		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
2422		✗	clear_bitmap(tex);
2423			}
2424
2425			int32_t col[3];
2426			/*
2427			if( color < 0 )
2428			{
2429			col[0]=draw_container.color_buffer[0];
2430			col[1]=draw_container.color_buffer[1];
2431			col[2]=draw_container.color_buffer[2];
2432			}
2433			else */
2434			{
2435		✗	col[0]=col[1]=col[2]=color;
2436			}
2437
2438		✗	if(tile > 0) // TILE
2439			{
2440		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
2441			}
2442			else // COMBO
2443			{
2444		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
2445		✗	const int32_t tiletodraw = combo_tile(c, x1, y1);
2446		✗	flip = flip ^ c.flip;
2447
2448		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
2449			}
2450
2451		✗	V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
2452		✗	V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(tex_height), col[1] };
2453		✗	V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(tex_width), static_cast<float>(tex_height), col[2] };
2454
2455
2456		✗	triangle3d_f(bmp, polytype, tex, &V1, &V2, &V3);
2457
2458		✗	if(mustDestroyBmp)
2459		✗	destroy_bitmap(tex);
2460			}
2461
2462
2463		✗	void do_drawbitmapr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2464			{
2465			//sdci[1]=layer
2466			//sdci[2]=bitmap
2467			//sdci[3]=sourcex
2468			//sdci[4]=sourcey
2469			//sdci[5]=sourcew
2470			//sdci[6]=sourceh
2471			//sdci[7]=destx
2472			//sdci[8]=desty
2473			//sdci[9]=destw
2474			//sdci[10]=desth
2475			//sdci[11]=rotation
2476			//sdci[12]=mask
2477
2478		✗	int32_t bitmapIndex = sdci[2]/10000;
2479		✗	int32_t sx = sdci[3]/10000;
2480		✗	int32_t sy = sdci[4]/10000;
2481		✗	int32_t sw = sdci[5]/10000;
2482		✗	int32_t sh = sdci[6]/10000;
2483		✗	int32_t dx = sdci[7]/10000;
2484		✗	int32_t dy = sdci[8]/10000;
2485		✗	int32_t dw = sdci[9]/10000;
2486		✗	int32_t dh = sdci[10]/10000;
2487		✗	float rot = sdci[11]/10000;
2488		✗	bool masked = (sdci[12] != 0);
2489
2490			//bugfix
2491		✗	sx = vbound(sx, 0, 512);
2492		✗	sy = vbound(sy, 0, 512);
2493		✗	sw = vbound(sw, 0, 512 - sx); //keep the w/h within range as well
2494		✗	sh = vbound(sh, 0, 512 - sy);
2495
2496
2497		✗	if(sx >= ZScriptDrawingRenderTarget::BitmapWidth || sy >= ZScriptDrawingRenderTarget::BitmapHeight)
2498		✗	return;
2499
2500		✗	bool stretched = (sw != dw || sh != dh);
2501
2502		✗	BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
2503
2504		✗	if(!sourceBitmap)
2505			{
2506		✗	Z_message("Warning: Screen->DrawBitmap(%d) contains invalid data or is not initialized.\n", bitmapIndex);
2507		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
2508		✗	return;
2509			}
2510
2511		✗	BITMAP* subBmp = 0;
2512
2513		✗	if(rot != 0)
2514			{
2515		✗	subBmp = script_drawing_commands.AquireSubBitmap(dw, dh);
2516
2517		✗	if(!subBmp)
2518			{
2519		✗	Z_scripterrlog("DrawBitmap() failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
2520		✗	return;
2521			}
2522			}
2523
2524
2525		✗	dx = dx + xoffset;
2526		✗	dy = dy + yoffset;
2527
2528		✗	if(stretched)
2529			{
2530		✗	if(masked)
2531			{
2532		✗	if(rot != 0)
2533			{
2534			//if ( rot == 4096 ) { //translucent
2535			// masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2536			// //rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2537			// draw_trans_sprite(bmp, subBmp, dx, dy);
2538			// //draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, 0);
2539
2540
2541			// }
2542			//else {
2543		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2544		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2545			//rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2546			//
2547
2548			// }
2549			}
2550			else
2551		✗	masked_stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
2552			}
2553			else
2554			{
2555		✗	if(rot != 0)
2556			{
2557			//if ( rot == 4096 ) { //translucent
2558			// stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2559			// draw_trans_sprite(bmp, subBmp, dx, dy);
2560			// }
2561			//else {
2562		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2563		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2564			// }
2565			}
2566			else
2567		✗	stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
2568			}
2569			}
2570			else
2571			{
2572		✗	if(masked)
2573			{
2574		✗	if(rot != 0)
2575			{
2576			//if ( rot == 4096 ) {//translucent
2577			// masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2578			//rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2579
2580			//masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2581			//rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2582			// draw_trans_sprite(bmp, subBmp, dx, dy);
2583			// }
2584			//else {
2585		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2586		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2587			// }
2588			}
2589			else
2590		✗	masked_blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
2591			}
2592			else
2593			{
2594		✗	if(rot != 0)
2595			{
2596			//if ( rot == 4096 ) { //translucent
2597			// blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2598			// draw_trans_sprite(bmp, subBmp, dx, dy);
2599			// }
2600			//else {
2601		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
2602		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2603			// }
2604			}
2605			else
2606		✗	blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
2607			}
2608			}
2609
2610			//cleanup
2611		✗	if(subBmp)
2612			{
2613		✗	script_drawing_commands.ReleaseSubBitmap(subBmp);
2614			}
2615			}
2616
2617
2618			//Draw]()
2619		✗	void do_drawbitmapexr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
2620			{
2621			/*
2622			//sdci[1]=layer
2623			//sdci[2]=bitmap
2624			//sdci[3]=sourcex
2625			//sdci[4]=sourcey
2626			//sdci[5]=sourcew
2627			//sdci[6]=sourceh
2628			//sdci[7]=destx
2629			//sdci[8]=desty
2630			//sdci[9]=destw
2631			//sdci[10]=desth
2632			//sdci[11]=rotation/angle
2633			//scdi[12] = pivot cx
2634			//sdci[13] = pivot cy
2635			//scdi[14] = effect flags
2636
2637
2638			const int32_t BITDX_NORMAL = 0;
2639			const int32_t BITDX_TRANS = 1; //Translucent
2640			const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
2641			const int32_t BITDX_HFLIP = 4; //Horizontal Flip
2642			const int32_t BITDX_VFLIP = 8; //Vertical Flip.
2643			//Note: Some modes cannot be combined. if a combination is not supported, an error
2644			// detailing this will be shown in allegro.log.
2645
2646			//scdi[15] = litcolour
2647			//The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
2648			/not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2649
2650			//sdci[16]=mask
2651
2652			*/
2653
2654		✗	int32_t bitmapIndex = sdci[2]/10000;
2655		✗	int32_t sx = sdci[3]/10000;
2656		✗	int32_t sy = sdci[4]/10000;
2657		✗	int32_t sw = sdci[5]/10000;
2658		✗	int32_t sh = sdci[6]/10000;
2659		✗	int32_t dx = sdci[7]/10000;
2660		✗	int32_t dy = sdci[8]/10000;
2661		✗	int32_t dw = sdci[9]/10000;
2662		✗	int32_t dh = sdci[10]/10000;
2663		✗	float rot = sdci[11]/10000;
2664		✗	int32_t cx = sdci[12]/10000;
2665		✗	int32_t cy = sdci[13]/10000;
2666		✗	int32_t mode = sdci[14]/10000;
2667		✗	int32_t litcolour = sdci[15]/10000;
2668		✗	bool masked = (sdci[16] != 0);
2669
2670
2671
2672			//bugfix
2673		✗	sx = vbound(sx, 0, 512);
2674		✗	sy = vbound(sy, 0, 512);
2675		✗	sw = vbound(sw, 0, 512 - sx); //keep the w/h within range as well
2676		✗	sh = vbound(sh, 0, 512 - sy);
2677
2678
2679		✗	if(sx >= ZScriptDrawingRenderTarget::BitmapWidth || sy >= ZScriptDrawingRenderTarget::BitmapHeight)
2680		✗	return;
2681
2682		✗	bool stretched = (sw != dw || sh != dh);
2683
2684		✗	BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
2685
2686		✗	if(!sourceBitmap)
2687			{
2688		✗	Z_message("Warning: Screen->DrawBitmap(%d) contains invalid data or is not initialized.\n", bitmapIndex);
2689		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
2690		✗	return;
2691			}
2692
2693		✗	BITMAP* subBmp = 0;
2694
2695			/*
2696			if ( bitmapIndex == -1 ) {
2697			blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
2698			}
2699			*/
2700
2701		✗	if(rot != 0 || mode != 0)
2702			{
2703		✗	subBmp = script_drawing_commands.AquireSubBitmap(dw, dh);
2704
2705		✗	if(!subBmp)
2706			{
2707		✗	Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
2708		✗	return;
2709			}
2710			}
2711
2712
2713		✗	dx = dx + xoffset;
2714		✗	dy = dy + yoffset;
2715
2716		✗	if(stretched)
2717			{
2718		✗	if(masked) //stretched and masked
2719			{
2720		✗	if ( rot == 0 ) //if not rotated
2721			{
2722		✗	switch(mode)
2723			{
2724			case 1:
2725			//transparent
2726		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2727		✗	draw_trans_sprite(bmp, subBmp, dx, dy);
2728		✗	break;
2729
2730
2731			case 2:
2732			//pivot?
2733		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2734		✗	pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
2735			//Pivoting requires two more args
2736		✗	break;
2737
2738			case 3:
2739			//pivot + trans
2740		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2741		✗	pivot_sprite_trans(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
2742		✗	break;
2743
2744			case 4:
2745			//flip v
2746		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2747		✗	draw_sprite_v_flip(bmp, subBmp, dx, dy);
2748		✗	break;
2749
2750			case 5:
2751			//trans + v flip
2752		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2753		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
2754		✗	break;
2755
2756			case 6:
2757			//pivot + v flip
2758		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2759		✗	pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
2760		✗	break;
2761
2762			case 8:
2763			//vlip h
2764		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2765		✗	draw_sprite_h_flip(bmp, subBmp, dx, dy);
2766		✗	break;
2767
2768			case 9:
2769			//trans + h flip
2770		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2771		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
2772		✗	break;
2773
2774			case 10:
2775			//flip H and pivot
2776		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
2777			//return error cannot pivot and h flip
2778		✗	break;
2779
2780			case 12:
2781			//vh flip
2782		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2783		✗	draw_sprite_vh_flip(bmp, subBmp, dx, dy);
2784		✗	break;
2785
2786			case 13:
2787			//trans + vh flip
2788		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2789		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
2790		✗	break;
2791
2792			case 14:
2793			//pivot and vh flip
2794		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
2795			//return error cannot both pivot and vh flip
2796		✗	break;
2797
2798			case 16:
2799			//lit
2800		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2801		✗	draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
2802		✗	break;
2803
2804			case 18:
2805			//pivot, lit
2806		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2807		✗	pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
2808		✗	break;
2809
2810			case 20:
2811			//lit + v flip
2812		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2813		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
2814		✗	break;
2815
2816			case 22:
2817			//Pivot, vflip, lit
2818		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2819		✗	pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
2820		✗	break;
2821
2822			case 24:
2823			//lit + h flip
2824		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2825		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
2826		✗	break;
2827
2828			case 26:
2829			//pivot + lit + hflip
2830		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
2831			//return error cannot pivot, lit, and flip
2832		✗	break;
2833
2834			case 28:
2835			//lit + vh flip
2836		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2837		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
2838		✗	break;
2839
2840			case 32: //gouraud
2841			//Probably not wort supporting.
2842			//masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2843			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
2844		✗	break;
2845
2846			case 0:
2847			//no effect
2848		✗	masked_stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
2849		✗	break;
2850
2851
2852			default:
2853		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
2854
2855
2856			}
2857			} //end if not rotated
2858
2859		✗	if ( rot != 0 ) //if rotated
2860			{
2861		✗	switch(mode)
2862			{
2863			case 1:
2864			//transparent
2865		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2866		✗	rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2867
2868		✗	break;
2869
2870			case 2:
2871			//pivot?
2872		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
2873			//return an error, cannot both rotate and pivot
2874		✗	break;
2875
2876			case 3:
2877			//pivot + trans
2878			//return an error, cannot both rotate and pivot
2879		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
2880		✗	break;
2881
2882			case 4:
2883			//flip v
2884		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2885		✗	rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2886		✗	break;
2887
2888			case 5:
2889			//trans + v flip
2890		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2891		✗	rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2892		✗	break;
2893
2894			case 6:
2895			//pivot + v flip
2896		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
2897			//return an error, cannot both rotate and pivot
2898		✗	break;
2899
2900			case 8:
2901			//flip h
2902		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
2903			//return an error, cannot both rotate and flip H
2904		✗	break;
2905
2906			case 9:
2907			//trans + h flip
2908		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
2909			//return an error, cannot rotate and flip a trans sprite
2910		✗	break;
2911
2912			case 10:
2913			//flip H and pivot
2914			//return error cannot pivot and h flip
2915		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
2916		✗	break;
2917
2918			case 12:
2919			//vh flip
2920			//return an error, cannot rotate and VH flip a trans sprite
2921		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
2922		✗	break;
2923
2924			case 13:
2925			//trans + vh flip
2926			//return an error, cannot rotate and VH flip a trans sprite
2927		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
2928		✗	break;
2929
2930			case 14:
2931			//pivot and vh flip
2932		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
2933			//return error cannot both pivot and vh flip
2934		✗	break;
2935
2936			case 16:
2937			//lit
2938		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2939		✗	rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
2940		✗	break;
2941
2942			case 18:
2943			//pivot, lit
2944			//return an error, cannot both rotate and pivot
2945		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
2946		✗	break;
2947
2948			case 20:
2949			//lit + vflip
2950		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2951		✗	rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
2952		✗	break;
2953
2954			case 22:
2955			//Pivot, vflip, lit
2956			//return an error, cannot both rotate and pivot
2957		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
2958		✗	break;
2959
2960			case 24:
2961			//lit + h flip
2962			//return an error, cannot both rotate and H flip
2963		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
2964		✗	break;
2965
2966			case 26:
2967			//pivot + lit + hflip
2968		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
2969			//return error cannot pivot, lit, and flip
2970		✗	break;
2971
2972			case 28:
2973			//lit + vh flip
2974			//return an error, cannot both rotate and VH flip
2975		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
2976		✗	break;
2977
2978			case 32: //gouraud
2979			//Probably not wort supporting.
2980			//masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2981			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
2982		✗	break;
2983
2984			case 0:
2985			//no effect.
2986		✗	masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
2987		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
2988		✗	break;
2989
2990			default:
2991		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
2992
2993			}
2994			}
2995			} //end if stretched and masked
2996
2997			else //stretched, not masked
2998			{
2999		✗	if ( rot == 0 ) //if not rotated
3000			{
3001		✗	switch(mode) {
3002			case 1:
3003			//transparent
3004		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3005		✗	draw_trans_sprite(bmp, subBmp, dx, dy);
3006		✗	break;
3007
3008
3009			case 2:
3010			//pivot?
3011		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3012		✗	pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3013			//Pivoting requires two more args
3014		✗	break;
3015
3016			case 3:
3017			//pivot + trans
3018		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3019		✗	pivot_sprite_trans(bmp, subBmp, dx,dy, cx, cy, degrees_to_fixed(rot));
3020		✗	break;
3021
3022			case 4:
3023			//flip v
3024		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3025		✗	draw_sprite_v_flip(bmp, subBmp, dx, dy);
3026		✗	break;
3027
3028			case 5:
3029			//trans + v flip
3030		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3031		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
3032		✗	break;
3033
3034			case 6:
3035			//pivot + v flip
3036		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3037		✗	pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3038		✗	break;
3039
3040			case 8:
3041			//vlip h
3042		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3043		✗	draw_sprite_h_flip(bmp, subBmp, dx, dy);
3044		✗	break;
3045
3046			case 9:
3047			//trans + h flip
3048		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3049		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
3050		✗	break;
3051
3052			case 10:
3053			//flip H and pivot
3054		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3055			//return error cannot pivot and h flip
3056		✗	break;
3057
3058			case 12:
3059			//vh flip
3060		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3061		✗	draw_sprite_vh_flip(bmp, subBmp, dx, dy);
3062		✗	break;
3063
3064			case 13:
3065			//trans + vh flip
3066		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3067		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
3068		✗	break;
3069
3070			case 14:
3071			//pivot and vh flip
3072		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3073			//return error cannot both pivot and vh flip
3074		✗	break;
3075
3076			case 16:
3077			//lit
3078		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3079		✗	draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
3080		✗	break;
3081
3082			case 18:
3083			//pivot, lit
3084		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3085		✗	pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3086		✗	break;
3087
3088			case 20:
3089			//lit + v flip
3090		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3091		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
3092		✗	break;
3093
3094			case 22:
3095			//Pivot, vflip, lit
3096		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3097		✗	pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3098		✗	break;
3099
3100			case 24:
3101			//lit + h flip
3102		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3103		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
3104		✗	break;
3105
3106			case 26:
3107			//pivot + lit + hflip
3108		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
3109			//return error cannot pivot, lit, and flip
3110		✗	break;
3111
3112			case 28:
3113			//lit + vh flip
3114		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3115		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
3116		✗	break;
3117
3118			case 32: //gouraud
3119			//Probably not wort supporting.
3120			//stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3121			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3122		✗	break;
3123
3124			case 0:
3125			//no effect
3126		✗	stretch_blit(sourceBitmap, bmp, sx, sy, sw, sh, dx, dy, dw, dh);
3127		✗	break;
3128
3129
3130			default:
3131		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3132
3133
3134			}
3135			} //end if not rotated
3136
3137		✗	if ( rot != 0 ) //if rotated
3138			{
3139		✗	switch(mode)
3140			{
3141			case 1:
3142		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
3143		✗	rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3144
3145		✗	break;
3146
3147			case 2:
3148			//pivot?
3149		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3150			//return an error, cannot both rotate and pivot
3151		✗	break;
3152
3153			case 3:
3154			//pivot + trans
3155			//return an error, cannot both rotate and pivot
3156		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3157		✗	break;
3158
3159			case 4:
3160			//flip v
3161		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3162		✗	rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3163		✗	break;
3164
3165			case 5:
3166			//trans + v flip
3167		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3168		✗	rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3169		✗	break;
3170
3171			case 6:
3172			//pivot + v flip
3173		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3174			//return an error, cannot both rotate and pivot
3175		✗	break;
3176
3177			case 8:
3178			//flip h
3179		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
3180			//return an error, cannot both rotate and flip H
3181		✗	break;
3182
3183			case 9:
3184			//trans + h flip
3185		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
3186			//return an error, cannot rotate and flip a trans sprite
3187		✗	break;
3188
3189			case 10:
3190			//flip H and pivot
3191			//return error cannot pivot and h flip
3192		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3193		✗	break;
3194
3195			case 12:
3196			//vh flip
3197			//return an error, cannot rotate and VH flip a trans sprite
3198		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3199		✗	break;
3200
3201			case 13:
3202			//trans + vh flip
3203			//return an error, cannot rotate and VH flip a trans sprite
3204		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3205		✗	break;
3206
3207			case 14:
3208			//pivot and vh flip
3209		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3210			//return error cannot both pivot and vh flip
3211		✗	break;
3212
3213			case 16:
3214			//lit
3215		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
3216		✗	rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3217		✗	break;
3218
3219			case 18:
3220			//pivot, lit
3221			//return an error, cannot both rotate and pivot
3222		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3223		✗	break;
3224
3225			case 20:
3226			//lit + vflip
3227		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
3228		✗	rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3229		✗	break;
3230
3231			case 22:
3232			//Pivot, vflip, lit
3233			//return an error, cannot both rotate and pivot
3234		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3235		✗	break;
3236
3237			case 24:
3238			//lit + h flip
3239			//return an error, cannot both rotate and H flip
3240		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
3241		✗	break;
3242
3243			case 26:
3244			//pivot + lit + hflip
3245		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
3246			//return error cannot pivot, lit, and flip
3247		✗	break;
3248
3249			case 28:
3250			//lit + vh flip
3251			//return an error, cannot both rotate and VH flip
3252		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3253		✗	break;
3254
3255			case 32: //gouraud
3256			//Probably not wort supporting.
3257			//stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3258			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3259		✗	break;
3260
3261			case 0:
3262			//no effect.
3263		✗	stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3264		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3265		✗	break;
3266
3267			default:
3268		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3269
3270			}
3271			}
3272
3273			} //end if stretched, but not masked
3274			}
3275			else //not stretched
3276			{
3277
3278		✗	if(masked) //if masked, but not stretched
3279			{
3280
3281		✗	if ( rot == 0 ) //if not rotated
3282			{
3283		✗	switch(mode)
3284			{
3285			case 1:
3286			//transparent
3287		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3288		✗	draw_trans_sprite(bmp, subBmp, dx, dy);
3289		✗	break;
3290
3291
3292			case 2:
3293			//pivot?
3294		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3295		✗	pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3296			//Pivoting requires two more args
3297		✗	break;
3298
3299			case 3:
3300			//pivot + trans
3301		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3302		✗	pivot_sprite_trans(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3303		✗	break;
3304
3305			case 4:
3306			//flip v
3307		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3308		✗	draw_sprite_v_flip(bmp, subBmp, dx, dy);
3309		✗	break;
3310
3311			case 5:
3312			//trans + v flip
3313		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3314		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
3315		✗	break;
3316
3317			case 6:
3318			//pivot + v flip
3319		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3320		✗	pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3321		✗	break;
3322
3323			case 8:
3324			//vlip h
3325		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3326		✗	draw_sprite_h_flip(bmp, subBmp, dx, dy);
3327		✗	break;
3328
3329			case 9:
3330			//trans + h flip
3331		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3332		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
3333		✗	break;
3334
3335			case 10:
3336			//flip H and pivot
3337		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3338			//return error cannot pivot and h flip
3339		✗	break;
3340
3341			case 12:
3342			//vh flip
3343		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3344		✗	draw_sprite_vh_flip(bmp, subBmp, dx, dy);
3345		✗	break;
3346
3347			case 13:
3348			//trans + vh flip
3349		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3350		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
3351		✗	break;
3352
3353			case 14:
3354			//pivot and vh flip
3355		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3356			//return error cannot both pivot and vh flip
3357		✗	break;
3358
3359			case 16:
3360			//lit
3361		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3362		✗	draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
3363		✗	break;
3364
3365			case 18:
3366			//pivot, lit
3367		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3368		✗	pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3369		✗	break;
3370
3371			case 20:
3372			//lit + v flip
3373		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3374		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
3375		✗	break;
3376
3377			case 22:
3378			//Pivot, vflip, lit
3379		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3380		✗	pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3381		✗	break;
3382
3383			case 24:
3384			//lit + h flip
3385		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3386		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
3387		✗	break;
3388
3389			case 26:
3390			//pivot + lit + hflip
3391		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
3392			//return error cannot pivot, lit, and flip
3393		✗	break;
3394
3395			case 28:
3396			//lit + vh flip
3397		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3398		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
3399		✗	break;
3400
3401			case 32: //gouraud
3402			//Probably not wort supporting.
3403			//stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3404			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3405		✗	break;
3406
3407			case 0:
3408			//no effect
3409		✗	masked_blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
3410		✗	break;
3411
3412
3413			default:
3414		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3415
3416
3417			}
3418			} //end if not rotated
3419
3420		✗	if ( rot != 0 ) //if rotated
3421			{
3422		✗	switch(mode)
3423			{
3424			case 1:
3425		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh); //transparent
3426		✗	rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3427
3428		✗	break;
3429
3430			case 2:
3431			//pivot?
3432		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3433			//return an error, cannot both rotate and pivot
3434		✗	break;
3435
3436			case 3:
3437			//pivot + trans
3438			//return an error, cannot both rotate and pivot
3439		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3440		✗	break;
3441
3442			case 4:
3443			//flip v
3444		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3445		✗	rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3446		✗	break;
3447
3448			case 5:
3449		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh); //trans + v flip
3450		✗	rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3451		✗	break;
3452
3453			case 6:
3454			//pivot + v flip
3455		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3456			//return an error, cannot both rotate and pivot
3457		✗	break;
3458
3459			case 8:
3460			//flip h
3461		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
3462			//return an error, cannot both rotate and flip H
3463		✗	break;
3464
3465			case 9:
3466			//trans + h flip
3467		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
3468			//return an error, cannot rotate and flip a trans sprite
3469		✗	break;
3470
3471			case 10:
3472			//flip H and pivot
3473			//return error cannot pivot and h flip
3474		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3475		✗	break;
3476
3477			case 12:
3478			//vh flip
3479			//return an error, cannot rotate and VH flip a trans sprite
3480		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3481		✗	break;
3482
3483			case 13:
3484			//trans + vh flip
3485			//return an error, cannot rotate and VH flip a trans sprite
3486		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3487		✗	break;
3488
3489			case 14:
3490			//pivot and vh flip
3491		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3492			//return error cannot both pivot and vh flip
3493		✗	break;
3494
3495			case 16:
3496			//lit
3497		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3498		✗	rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3499		✗	break;
3500
3501			case 18:
3502			//pivot, lit
3503			//return an error, cannot both rotate and pivot
3504		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3505		✗	break;
3506
3507			case 20:
3508			//lit + vflip
3509		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3510		✗	rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3511		✗	break;
3512
3513			case 22:
3514			//Pivot, vflip, lit
3515			//return an error, cannot both rotate and pivot
3516		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3517		✗	break;
3518
3519			case 24:
3520			//lit + h flip
3521			//return an error, cannot both rotate and H flip
3522		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
3523		✗	break;
3524
3525			case 26:
3526			//pivot + lit + hflip
3527		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
3528			//return error cannot pivot, lit, and flip
3529		✗	break;
3530
3531			case 28:
3532			//lit + vh flip
3533			//return an error, cannot both rotate and VH flip
3534		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3535		✗	break;
3536
3537			case 32: //gouraud
3538			//Probably not wort supporting.
3539			//stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
3540			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3541		✗	break;
3542
3543			case 0:
3544			//no effect.
3545		✗	masked_blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3546		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3547		✗	break;
3548
3549			default:
3550		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3551
3552			}
3553			} //end rtated, masked
3554			} //end if masked
3555
3556			else //not masked, and not stretched; just blit
3557			{
3558
3559		✗	if ( rot == 0 ) //if not rotated
3560			{
3561		✗	switch(mode)
3562			{
3563			case 1:
3564			//transparent
3565		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3566		✗	draw_trans_sprite(bmp, subBmp, dx, dy);
3567		✗	break;
3568
3569
3570			case 2:
3571			//pivot?
3572		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3573		✗	pivot_sprite(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3574			//Pivoting requires two more args
3575		✗	break;
3576
3577			case 3:
3578			//pivot + trans
3579		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3580		✗	pivot_sprite_trans(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3581		✗	break;
3582
3583			case 4:
3584			//flip v
3585		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3586		✗	draw_sprite_v_flip(bmp, subBmp, dx, dy);
3587		✗	break;
3588
3589			case 5:
3590			//trans + v flip
3591		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3592		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
3593		✗	break;
3594
3595			case 6:
3596			//pivot + v flip
3597		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3598		✗	pivot_sprite_v_flip(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
3599		✗	break;
3600
3601			case 8:
3602			//vlip h
3603		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3604		✗	draw_sprite_h_flip(bmp, subBmp, dx, dy);
3605		✗	break;
3606
3607			case 9:
3608			//trans + h flip
3609		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3610		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
3611		✗	break;
3612
3613			case 10:
3614			//flip H and pivot
3615		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3616			//return error cannot pivot and h flip
3617		✗	break;
3618
3619			case 12:
3620			//vh flip
3621		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3622		✗	draw_sprite_vh_flip(bmp, subBmp, dx, dy);
3623		✗	break;
3624
3625			case 13:
3626			//trans + vh flip
3627		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3628		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
3629		✗	break;
3630
3631			case 14:
3632			//pivot and vh flip
3633		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3634			//return error cannot both pivot and vh flip
3635		✗	break;
3636
3637			case 16:
3638			//lit
3639		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3640		✗	draw_lit_sprite(bmp, subBmp, dx, dy, litcolour);
3641		✗	break;
3642
3643			case 18:
3644			//pivot, lit
3645		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3646		✗	pivot_sprite_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3647		✗	break;
3648
3649			case 20:
3650			//lit + v flip
3651		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3652		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
3653		✗	break;
3654
3655			case 22:
3656			//Pivot, vflip, lit
3657		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3658		✗	pivot_sprite_v_flip_lit(bmp, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
3659		✗	break;
3660
3661			case 24:
3662			//lit + h flip
3663		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3664		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
3665		✗	break;
3666
3667			case 26:
3668			//pivot + lit + hflip
3669		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
3670			//return error cannot pivot, lit, and flip
3671		✗	break;
3672
3673			case 28:
3674			//lit + vh flip
3675		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3676		✗	draw_sprite_ex(bmp, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
3677		✗	break;
3678
3679			case 32: //gouraud
3680			//Probably not wort supporting.
3681			//blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3682			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3683		✗	break;
3684
3685			case 0:
3686			//no effect
3687		✗	blit(sourceBitmap, bmp, sx, sy, dx, dy, dw, dh);
3688		✗	break;
3689
3690
3691			default:
3692		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3693
3694
3695			}
3696			} //end if not rotated
3697
3698		✗	if ( rot != 0 ) //if rotated
3699			{
3700		✗	switch(mode)
3701			{
3702			case 1:
3703		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);//transparent
3704		✗	rotate_sprite_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3705
3706		✗	break;
3707
3708			case 2:
3709			//pivot?
3710		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3711			//return an error, cannot both rotate and pivot
3712		✗	break;
3713
3714			case 3:
3715			//pivot + trans
3716			//return an error, cannot both rotate and pivot
3717		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3718		✗	break;
3719
3720			case 4:
3721			//flip v
3722		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3723		✗	rotate_sprite_v_flip(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3724		✗	break;
3725
3726			case 5:
3727			//trans + v flip
3728		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3729		✗	rotate_sprite_v_flip_trans(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3730		✗	break;
3731
3732			case 6:
3733			//pivot + v flip
3734		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3735			//return an error, cannot both rotate and pivot
3736		✗	break;
3737
3738			case 8:
3739			//flip h
3740		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
3741			//return an error, cannot both rotate and flip H
3742		✗	break;
3743
3744			case 9:
3745			//trans + h flip
3746		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
3747			//return an error, cannot rotate and flip a trans sprite
3748		✗	break;
3749
3750			case 10:
3751			//flip H and pivot
3752			//return error cannot pivot and h flip
3753		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
3754		✗	break;
3755
3756			case 12:
3757			//vh flip
3758			//return an error, cannot rotate and VH flip a trans sprite
3759		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3760		✗	break;
3761
3762			case 13:
3763			//trans + vh flip
3764			//return an error, cannot rotate and VH flip a trans sprite
3765		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
3766		✗	break;
3767
3768			case 14:
3769			//pivot and vh flip
3770		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3771			//return error cannot both pivot and vh flip
3772		✗	break;
3773
3774			case 16:
3775			//lit
3776		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3777		✗	rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3778		✗	break;
3779
3780			case 18:
3781			//pivot, lit
3782			//return an error, cannot both rotate and pivot
3783		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
3784		✗	break;
3785
3786			case 20:
3787			//lit + vflip
3788		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3789		✗	rotate_sprite_v_flip_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
3790		✗	break;
3791
3792			case 22:
3793			//Pivot, vflip, lit
3794			//return an error, cannot both rotate and pivot
3795		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
3796		✗	break;
3797
3798			case 24:
3799			//lit + h flip
3800			//return an error, cannot both rotate and H flip
3801		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
3802		✗	break;
3803
3804			case 26:
3805			//pivot + lit + hflip
3806		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
3807			//return error cannot pivot, lit, and flip
3808		✗	break;
3809
3810			case 28:
3811			//lit + vh flip
3812			//return an error, cannot both rotate and VH flip
3813		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
3814		✗	break;
3815
3816			case 32: //gouraud
3817			//Probably not wort supporting.
3818			//blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3819			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
3820		✗	break;
3821
3822			case 0:
3823			//no effect.
3824		✗	blit(sourceBitmap, subBmp, sx, sy, 0, 0, dw, dh);
3825		✗	rotate_sprite(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
3826		✗	break;
3827
3828			default:
3829		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
3830
3831			}
3832			} //end if rotated
3833			} //end if not masked
3834			} //end if not stretched
3835
3836			//cleanup
3837		✗	if(subBmp)
3838			{
3839		✗	script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
3840			}
3841			}
3842
3843
3844		✗	void do_drawquad3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
3845			{
3846			//sdci[1]=layer
3847			//sdci[2]=pos[12]
3848			//sdci[3]=uv[8]
3849			//sdci[4]=color[4]
3850			//sdci[5]=size[2]
3851			//sdci[6]=flip
3852			//sdci[7]=tile/combo
3853			//sdci[8]=polytype
3854
3855		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
3856
3857		✗	if(!v_ptr)
3858			{
3859		✗	al_trace("Quad3d: Vector pointer is null! Internal error. \n");
3860		✗	return;
3861			}
3862
3863		✗	std::vector<int32_t> &v = *v_ptr;
3864
3865		✗	if(v.empty())
3866		✗	return;
3867
3868		✗	int32_t* pos = &v[0];
3869		✗	int32_t* uv = &v[12];
3870		✗	int32_t* col = &v[20];
3871		✗	int32_t* size = &v[24];
3872
3873		✗	int32_t w = size[0]; //magic numerical constants... yuck.
3874		✗	int32_t h = size[1];
3875		✗	int32_t flip = (sdci[6]/10000)&3;
3876		✗	int32_t tile = sdci[7]/10000;
3877		✗	int32_t polytype = sdci[8]/10000;
3878
3879		✗	polytype = vbound(polytype, 0, 14);
3880
3881		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
3882			{
3883		✗	Z_message("Quad3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
3884		✗	return; //non power of two error
3885			}
3886
3887		✗	int32_t tex_width = w*16;
3888		✗	int32_t tex_height = h*16;
3889
3890		✗	bool mustDestroyBmp = false;
3891		✗	BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
3892
3893		✗	if(!tex)
3894			{
3895		✗	mustDestroyBmp = true;
3896		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
3897		✗	clear_bitmap(tex);
3898			}
3899
3900		✗	if(tile > 0) // TILE
3901			{
3902		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
3903			}
3904			else // COMBO
3905			{
3906		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
3907		✗	const int32_t tiletodraw = combo_tile(c, 0, 0);
3908		✗	flip = flip ^ c.flip;
3909
3910		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
3911			}
3912
3913		✗	V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
3914		✗	V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
3915		✗	V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
3916		✗	V3D_f V4 = { static_cast<float>(pos[9]+xoffset), static_cast<float>(pos[10]+yoffset), static_cast<float>(pos[11]), static_cast<float>(uv[6]), static_cast<float>(uv[7]), col[3] };
3917
3918		✗	quad3d_f(bmp, polytype, tex, &V1, &V2, &V3, &V4);
3919
3920		✗	if(mustDestroyBmp)
3921		✗	destroy_bitmap(tex);
3922
3923			}
3924
3925
3926
3927		✗	void do_drawtriangle3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
3928			{
3929			//sdci[1]=layer
3930			//sdci[2]=pos[9]
3931			//sdci[3]=uv[6]
3932			//sdci[4]=color[3]
3933			//sdci[5]=size[2]
3934			//sdci[6]=flip
3935			//sdci[7]=tile/combo
3936			//sdci[8]=polytype
3937
3938		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
3939
3940		✗	if(!v_ptr)
3941			{
3942		✗	al_trace("Triange3d: Vector pointer is null! Internal error. \n");
3943		✗	return;
3944			}
3945
3946		✗	std::vector<int32_t> &v = *v_ptr;
3947
3948		✗	if(v.empty())
3949		✗	return;
3950
3951		✗	int32_t* pos = &v[0];
3952		✗	int32_t* uv = &v[9];
3953		✗	int32_t* col = &v[15];
3954		✗	int32_t* size = &v[18];
3955
3956		✗	int32_t w = size[0]; //magic numerical constants... yuck.
3957		✗	int32_t h = size[1];
3958		✗	int32_t flip = (sdci[6]/10000)&3;
3959		✗	int32_t tile = sdci[7]/10000;
3960		✗	int32_t polytype = sdci[8]/10000;
3961
3962		✗	polytype = vbound(polytype, 0, 14);
3963
3964		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
3965			{
3966		✗	Z_message("Triangle3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
3967		✗	return; //non power of two error
3968			}
3969
3970		✗	int32_t tex_width = w*16;
3971		✗	int32_t tex_height = h*16;
3972
3973		✗	bool mustDestroyBmp = false;
3974		✗	BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
3975
3976		✗	if(!tex)
3977			{
3978		✗	mustDestroyBmp = true;
3979		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
3980		✗	clear_bitmap(tex);
3981			}
3982
3983		✗	if(tile > 0) // TILE
3984			{
3985		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
3986			}
3987			else // COMBO
3988			{
3989		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
3990		✗	const int32_t tiletodraw = combo_tile(c, 0, 0);
3991		✗	flip = flip ^ c.flip;
3992
3993		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
3994			}
3995
3996		✗	V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
3997		✗	V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
3998		✗	V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
3999
4000		✗	triangle3d_f(bmp, polytype, tex, &V1, &V2, &V3);
4001
4002		✗	if(mustDestroyBmp)
4003		✗	destroy_bitmap(tex);
4004
4005			}
4006
4007		✗	void bmp_do_rectr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4008			{
4009			//Z_scripterrlog("rect sdci[13] is: %d\n", sdci[13]);
4010			//sdci[1]=layer
4011			//sdci[2]=x
4012			//sdci[3]=y
4013			//sdci[4]=x2
4014			//sdci[5]=y2
4015			//sdci[6]=color
4016			//sdci[7]=scale factor
4017			//sdci[8]=rotation anchor x
4018			//sdci[9]=rotation anchor y
4019			//sdci[10]=rotation angle
4020			//sdci[11]=fill
4021			//sdci[12]=opacity
4022			//sdci[17] Bitmap Pointer
4023		✗	if(sdci[7]==0) //scale
4024			{
4025		✗	return;
4026			}
4027		✗	if ( sdci[17] <= 0 )
4028			{
4029		✗	Z_scripterrlog("bitmap->Rectangle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4030		✗	return;
4031			}
4032		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4033		✗	if ( refbmp == NULL ) return;
4034
4035		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4036
4037		✗	int32_t x1=sdci[2]/10000;
4038		✗	int32_t y1=sdci[3]/10000;
4039		✗	int32_t x2=sdci[4]/10000;
4040		✗	int32_t y2=sdci[5]/10000;
4041
4042
4043		✗	if(x1>x2)
4044			{
4045		✗	zc_swap(x1,x2);
4046			}
4047
4048		✗	if(y1>y2)
4049			{
4050		✗	zc_swap(y1,y2);
4051			}
4052
4053		✗	if(sdci[7] != 10000)
4054			{
4055		✗	int32_t w=x2-x1+1;
4056		✗	int32_t h=y2-y1+1;
4057		✗	int32_t w2=(w*sdci[7])/10000;
4058		✗	int32_t h2=(h*sdci[7])/10000;
4059		✗	x1=x1-((w2-w)/2);
4060		✗	x2=x2+((w2-w)/2);
4061		✗	y1=y1-((h2-h)/2);
4062		✗	y2=y2+((h2-h)/2);
4063			}
4064
4065		✗	int32_t color=sdci[6]/10000;
4066
4067		✗	if(sdci[12]/10000<=127) //translucent
4068			{
4069		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4070			}
4071
4072		✗	if(sdci[10]==0) //no rotation
4073			{
4074		✗	if(sdci[11]) //filled
4075			{
4076		✗	rectfill(refbmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
4077			}
4078			else //outline
4079			{
4080		✗	rect(refbmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
4081			}
4082			}
4083			else //rotate
4084			{
4085			int32_t xy[16];
4086		✗	int32_t rx=sdci[8]/10000;
4087		✗	int32_t ry=sdci[9]/10000;
4088		✗	fixed ra1=itofix(sdci[10]%10000)/10000;
4089		✗	fixed ra2=itofix(sdci[10]/10000);
4090		✗	fixed ra=ra1+ra2;
4091		✗	ra = (ra/360)*256;
4092
4093		✗	fixed fcosa = fixcos(ra);
4094		✗	fixed fsina = fixsin(ra);
4095
4096		✗	xy[ 0]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry))); //x1
4097		✗	xy[ 1]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry))); //y1
4098		✗	xy[ 2]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y1 - ry))); //x2
4099		✗	xy[ 3]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y1 - ry))); //y1
4100		✗	xy[ 4]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry))); //x2
4101		✗	xy[ 5]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry))); //y2
4102		✗	xy[ 6]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y2 - ry))); //x1
4103		✗	xy[ 7]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y2 - ry))); //y2
4104		✗	xy[ 8]=xoffset+rx + fixtoi((fcosa * (x1 - rx) - fsina * (y1 - ry + 1))); //x1
4105		✗	xy[ 9]=yoffset+ry + fixtoi((fsina * (x1 - rx) + fcosa * (y1 - ry + 1))); //y1
4106		✗	xy[10]=xoffset+rx + fixtoi((fcosa * (x2 - rx - 1) - fsina * (y1 - ry))); //x2
4107		✗	xy[11]=yoffset+ry + fixtoi((fsina * (x2 - rx - 1) + fcosa * (y1 - ry))); //y1
4108		✗	xy[12]=xoffset+rx + fixtoi((fcosa * (x2 - rx) - fsina * (y2 - ry - 1))); //x2
4109		✗	xy[13]=yoffset+ry + fixtoi((fsina * (x2 - rx) + fcosa * (y2 - ry - 1))); //y2
4110		✗	xy[14]=xoffset+rx + fixtoi((fcosa * (x1 - rx + 1) - fsina * (y2 - ry))); //x1
4111		✗	xy[15]=yoffset+ry + fixtoi((fsina * (x1 - rx + 1) + fcosa * (y2 - ry))); //y2
4112
4113		✗	if(sdci[11]) //filled
4114			{
4115		✗	polygon(refbmp, 4, xy, color);
4116			}
4117			else //outline
4118			{
4119		✗	line(refbmp, xy[0], xy[1], xy[10], xy[11], color);
4120		✗	line(refbmp, xy[2], xy[3], xy[12], xy[13], color);
4121		✗	line(refbmp, xy[4], xy[5], xy[14], xy[15], color);
4122		✗	line(refbmp, xy[6], xy[7], xy[ 8], xy[ 9], color);
4123			}
4124			}
4125
4126		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4127			}
4128
4129		✗	void bmp_do_framer(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4130			{
4131			//sdci[1]=layer
4132			//sdci[2]=x
4133			//sdci[3]=y
4134			//sdci[4]=tile
4135			//sdci[5]=cset
4136			//sdci[6]=width
4137			//sdci[7]=height
4138			//sdci[8]=overlay
4139			//sdci[9]=opacity
4140
4141		✗	if ( sdci[17] <= 0 )
4142			{
4143		✗	Z_scripterrlog("bitmap->DrawFrame() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4144		✗	return;
4145			}
4146		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4147		✗	if ( refbmp == NULL ) return;
4148
4149		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4150
4151		✗	int32_t x=sdci[2]/10000;
4152		✗	int32_t y=sdci[3]/10000;
4153
4154		✗	int32_t tile=sdci[4]/10000;
4155		✗	int32_t cs=sdci[5]/10000;
4156		✗	int32_t w=sdci[6]/10000;
4157		✗	int32_t h=sdci[7]/10000;
4158		✗	bool overlay=sdci[8];
4159		✗	bool trans=(sdci[9]/10000<=127);
4160
4161		✗	frame2x2(refbmp, &QMisc, x + xoffset, y + yoffset, tile, cs, w, h, 0, overlay, trans);
4162			}
4163
4164
4165		✗	void bmp_do_circler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4166			{
4167			//sdci[1]=layer
4168			//sdci[2]=x
4169			//sdci[3]=y
4170			//sdci[4]=radius
4171			//sdci[5]=color
4172			//sdci[6]=scale factor
4173			//sdci[7]=rotation anchor x
4174			//sdci[8]=rotation anchor y
4175			//sdci[9]=rotation angle
4176			//sdci[10]=fill
4177			//sdci[11]=opacity
4178			//sdci[17] Bitmap Pointer
4179		✗	if(sdci[6]==0) //scale
4180			{
4181		✗	return;
4182			}
4183		✗	if ( sdci[17] <= 0 )
4184			{
4185		✗	Z_scripterrlog("bitmap->Circle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4186		✗	return;
4187			}
4188		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4189		✗	if ( refbmp == NULL ) return;
4190
4191		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4192
4193		✗	int32_t x1=sdci[2]/10000;
4194		✗	int32_t y1=sdci[3]/10000;
4195		✗	qword r=sdci[4];
4196
4197		✗	if(sdci[6] != 10000)
4198			{
4199		✗	r*=sdci[6];
4200		✗	r/=10000;
4201			}
4202
4203		✗	r/=10000;
4204		✗	int32_t color=sdci[5]/10000;
4205
4206		✗	if(sdci[11]/10000<=127) //translucent
4207			{
4208		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4209			}
4210
4211		✗	if(sdci[9]!=0&&(sdci[2]!=sdci[7]||sdci[3]!=sdci[8])) //rotation
4212			{
4213			int32_t xy[2];
4214		✗	int32_t rx=sdci[7]/10000;
4215		✗	int32_t ry=sdci[8]/10000;
4216		✗	fixed ra1=itofix(sdci[9]%10000)/10000;
4217		✗	fixed ra2=itofix(sdci[9]/10000);
4218		✗	fixed ra=ra1+ra2;
4219		✗	ra = (ra/360)*256;
4220
4221		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4222		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4223		✗	x1=xy[0];
4224		✗	y1=xy[1];
4225			}
4226
4227		✗	if(sdci[10]) //filled
4228			{
4229		✗	circlefill(refbmp, x1+xoffset, y1+yoffset, r, color);
4230			}
4231			else //outline
4232			{
4233		✗	circle(refbmp, x1+xoffset, y1+yoffset, r, color);
4234			}
4235
4236		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4237			}
4238
4239
4240		✗	void bmp_do_arcr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4241			{
4242			//sdci[1]=layer
4243			//sdci[2]=x
4244			//sdci[3]=y
4245			//sdci[4]=radius
4246			//sdci[5]=start angle
4247			//sdci[6]=end angle
4248			//sdci[7]=color
4249			//sdci[8]=scale factor
4250			//sdci[9]=rotation anchor x
4251			//sdci[10]=rotation anchor y
4252			//sdci[11]=rotation angle
4253			//sdci[12]=closed
4254			//sdci[13]=fill
4255			//sdci[14]=opacity
4256			//sdci[17] Bitmap Pointer
4257
4258		✗	if(sdci[8]==0) //scale
4259			{
4260		✗	return;
4261			}
4262		✗	if ( sdci[17] <= 0 )
4263			{
4264		✗	Z_scripterrlog("bitmap->Arc() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4265		✗	return;
4266			}
4267		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4268		✗	if ( refbmp == NULL ) return;
4269
4270		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4271
4272		✗	int32_t cx=sdci[2]/10000;
4273		✗	int32_t cy=sdci[3]/10000;
4274		✗	qword r=sdci[4];
4275
4276		✗	if(sdci[8] != 10000)
4277			{
4278		✗	r*=sdci[8];
4279		✗	r/=10000;
4280			}
4281
4282		✗	r/=10000;
4283
4284		✗	int32_t color=sdci[7]/10000;
4285
4286		✗	fixed ra1=itofix(sdci[11]%10000)/10000;
4287		✗	fixed ra2=itofix(sdci[11]/10000);
4288		✗	fixed ra=ra1+ra2;
4289		✗	ra = (ra/360)*256;
4290
4291
4292		✗	fixed a1=itofix(sdci[5]%10000)/10000;
4293		✗	fixed a2=itofix(sdci[5]/10000);
4294		✗	fixed sa=a1+a2;
4295		✗	sa = (sa/360)*256;
4296
4297		✗	a1=itofix(sdci[6]%10000)/10000;
4298		✗	a2=itofix(sdci[6]/10000);
4299		✗	fixed ea=a1+a2;
4300		✗	ea = (ea/360)*256;
4301
4302		✗	if(sdci[11]!=0) //rotation
4303			{
4304		✗	int32_t rx=sdci[9]/10000;
4305		✗	int32_t ry=sdci[10]/10000;
4306
4307		✗	cx=rx + fixtoi((fixcos(ra) * (cx - rx) - fixsin(ra) * (cy - ry))); //x1
4308		✗	cy=ry + fixtoi((fixsin(ra) * (cx - rx) + fixcos(ra) * (cy - ry))); //y1
4309		✗	ea-=ra;
4310		✗	sa-=ra;
4311			}
4312
4313		✗	int32_t fx=cx+fixtoi(fixcos(-(ea+sa)/2)*r/2);
4314		✗	int32_t fy=cy+fixtoi(fixsin(-(ea+sa)/2)*r/2);
4315
4316		✗	if(sdci[12]) //closed
4317			{
4318		✗	if(sdci[13]) //filled
4319			{
4320		✗	clear_bitmap(prim_bmp);
4321		✗	arc(prim_bmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
4322		✗	line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
4323		✗	line(prim_bmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
4324		✗	floodfill(prim_bmp, zc_max(0,fx)+xoffset, zc_max(0,fy)+yoffset, color);
4325
4326		✗	if(sdci[14]/10000<=127) //translucent
4327			{
4328		✗	draw_trans_sprite(refbmp, prim_bmp, 0,0);
4329			}
4330			else
4331			{
4332		✗	draw_sprite(refbmp, prim_bmp, 0,0);
4333			}
4334			}
4335			else
4336			{
4337		✗	arc(refbmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
4338		✗	line(refbmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-sa)*r), cy+yoffset+fixtoi(fixsin(-sa)*r), color);
4339		✗	line(refbmp, cx+xoffset, cy+yoffset, cx+xoffset+fixtoi(fixcos(-ea)*r), cy+yoffset+fixtoi(fixsin(-ea)*r), color);
4340			}
4341			}
4342			else
4343			{
4344		✗	if(sdci[14]/10000<=127) //translucent
4345			{
4346		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4347			}
4348
4349		✗	arc(refbmp, cx+xoffset, cy+yoffset, sa, ea, int32_t(r), color);
4350		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4351			}
4352			}
4353
4354
4355		✗	void bmp_do_ellipser(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4356			{
4357			//sdci[1]=layer
4358			//sdci[2]=x
4359			//sdci[3]=y
4360			//sdci[4]=radiusx
4361			//sdci[5]=radiusy
4362			//sdci[6]=color
4363			//sdci[7]=scale factor
4364			//sdci[8]=rotation anchor x
4365			//sdci[9]=rotation anchor y
4366			//sdci[10]=rotation angle
4367			//sdci[11]=fill
4368			//sdci[12]=opacity
4369			//sdci[17] Bitmap Pointer
4370
4371		✗	if(sdci[7]==0) //scale
4372			{
4373		✗	return;
4374			}
4375		✗	if ( sdci[17] <= 0 )
4376			{
4377		✗	Z_scripterrlog("bitmap->Ellipse() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4378		✗	return;
4379			}
4380		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4381		✗	if ( refbmp == NULL ) return;
4382
4383		✗	int32_t x1=sdci[2]/10000;
4384		✗	int32_t y1=sdci[3]/10000;
4385		✗	int32_t radx=sdci[4]/10000;
4386		✗	radx*=sdci[7]/10000;
4387		✗	int32_t rady=sdci[5]/10000;
4388		✗	rady*=sdci[7]/10000;
4389		✗	int32_t color=sdci[6]/10000;
4390		✗	float rotation = sdci[10]/10000;
4391
4392		✗	int32_t rx=sdci[8]/10000;
4393		✗	int32_t ry=sdci[9]/10000;
4394		✗	fixed ra1=itofix(sdci[10]%10000)/10000;
4395		✗	fixed ra2=itofix(sdci[10]/10000);
4396		✗	fixed ra=ra1+ra2;
4397		✗	ra = (ra/360)*256;
4398
4399		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4400
4401			int32_t xy[2];
4402		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4403		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4404		✗	x1=xy[0];
4405		✗	y1=xy[1];
4406
4407		✗	if(radx<1||rady<1||radx>255||rady>255) return;
4408
4409		✗	BITMAP* bitty = script_drawing_commands.AquireSubBitmap(radx*2+1, rady*2+1);
4410
4411		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4412
4413		✗	if(sdci[11]) //filled
4414			{
4415
4416		✗	if(sdci[12]/10000<128) //translucent
4417			{
4418		✗	clear_bitmap(prim_bmp);
4419		✗	ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
4420		✗	rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4421		✗	draw_trans_sprite(refbmp, prim_bmp, 0, 0);
4422			}
4423			else // no opacity
4424			{
4425		✗	ellipsefill(bitty, radx, rady, radx, rady, color==0?255:color);
4426		✗	rotate_sprite(refbmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4427			}
4428			}
4429			else //not filled
4430			{
4431		✗	if(sdci[12]/10000<128) //translucent
4432			{
4433		✗	clear_bitmap(prim_bmp);
4434		✗	ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
4435		✗	rotate_sprite(prim_bmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4436		✗	draw_trans_sprite(refbmp, prim_bmp, 0, 0);
4437			}
4438			else // no opacity
4439			{
4440		✗	ellipse(bitty, radx, rady, radx, rady, color==0?255:color);
4441		✗	rotate_sprite(refbmp, bitty, x1+xoffset-radx,y1+yoffset-rady, degrees_to_fixed(rotation));
4442			}
4443			}
4444
4445			// Since 0 is the transparent color, the stuff above will fail if the ellipse color is also 0.
4446			// Instead, it uses color 255 and replaces it afterward. That'll also screw up color 255 around
4447			// the ellipse, but it shouldn't be used anyway.
4448		✗	if(color==0)
4449			{
4450			// This is very slow, so check the smallest possible square
4451		✗	int32_t endx=zc_min(bmp->w-1, x1+zc_max(radx, rady));
4452		✗	int32_t endy=zc_min(bmp->h-1, y1+zc_max(radx, rady));
4453
4454		✗	for(int32_t y=zc_max(0, y1-zc_max(radx, rady)); y<=endy; y++)
4455		✗	for(int32_t x=zc_max(0, x1-zc_max(radx, rady)); x<=endx; x++)
4456		✗	if(getpixel(refbmp, x, y)==255)
4457		✗	putpixel(refbmp, x, y, 0);
4458			}
4459
4460		✗	script_drawing_commands.ReleaseSubBitmap(bitty);
4461			}
4462
4463
4464		✗	void bmp_do_liner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4465			{
4466			//sdci[1]=layer
4467			//sdci[2]=x
4468			//sdci[3]=y
4469			//sdci[4]=x2
4470			//sdci[5]=y2
4471			//sdci[6]=color
4472			//sdci[7]=scale factor
4473			//sdci[8]=rotation anchor x
4474			//sdci[9]=rotation anchor y
4475			//sdci[10]=rotation angle
4476			//sdci[11]=opacity
4477			//sdci[17] Bitmap Pointer
4478		✗	if(sdci[7]==0) //scale
4479			{
4480		✗	return;
4481			}
4482
4483		✗	if ( sdci[17] <= 0 )
4484			{
4485		✗	Z_scripterrlog("bitmap->Line() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4486		✗	return;
4487			}
4488
4489		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4490		✗	if ( refbmp == NULL ) return;
4491
4492		✗	int32_t x1=sdci[2]/10000;
4493		✗	int32_t y1=sdci[3]/10000;
4494		✗	int32_t x2=sdci[4]/10000;
4495		✗	int32_t y2=sdci[5]/10000;
4496
4497		✗	if(sdci[7] != 10000)
4498			{
4499		✗	int32_t w=x2-x1+1;
4500		✗	int32_t h=y2-y1+1;
4501		✗	int32_t w2=int32_t(w*((double)sdci[7]/10000.0));
4502		✗	int32_t h2=int32_t(h*((double)sdci[7]/10000.0));
4503		✗	x1=x1-((w2-w)/2);
4504		✗	x2=x2+((w2-w)/2);
4505		✗	y1=y1-((h2-h)/2);
4506		✗	y2=y2+((h2-h)/2);
4507			}
4508
4509		✗	int32_t color=sdci[6]/10000;
4510
4511		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4512
4513		✗	if(sdci[11]/10000<=127) //translucent
4514			{
4515		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4516			}
4517
4518		✗	if(sdci[10]!=0) //rotation
4519			{
4520			int32_t xy[4];
4521		✗	int32_t rx=sdci[8]/10000;
4522		✗	int32_t ry=sdci[9]/10000;
4523		✗	fixed ra1=itofix(sdci[10]%10000)/10000;
4524		✗	fixed ra2=itofix(sdci[10]/10000);
4525		✗	fixed ra=ra1+ra2;
4526
4527		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4528		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4529		✗	xy[ 2]=rx + fixtoi((fixcos(ra) * (x2 - rx) - fixsin(ra) * (y2 - ry))); //x2
4530		✗	xy[ 3]=ry + fixtoi((fixsin(ra) * (x2 - rx) + fixcos(ra) * (y2 - ry))); //y2
4531		✗	x1=xy[0];
4532		✗	y1=xy[1];
4533		✗	x2=xy[2];
4534		✗	y2=xy[3];
4535			}
4536
4537		✗	line(refbmp, x1+xoffset, y1+yoffset, x2+xoffset, y2+yoffset, color);
4538		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4539			}
4540
4541
4542		✗	void bmp_do_spliner(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4543			{
4544			/* layer, x1, y1, x2, y2, x3, y3, x4, y4, color, opacity */
4545			//sdci[17] Bitmap Pointer
4546
4547		✗	int32_t points[8] = { xoffset + (sdci[2]/10000), yoffset + (sdci[3]/10000),
4548		✗	xoffset + (sdci[4]/10000), yoffset + (sdci[5]/10000),
4549		✗	xoffset + (sdci[6]/10000), yoffset + (sdci[7]/10000),
4550		✗	xoffset + (sdci[8]/10000), yoffset + (sdci[9]/10000)
4551			};
4552
4553		✗	if(sdci[11]/10000 < 128) //translucent
4554			{
4555		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4556			}
4557
4558		✗	if ( sdci[17] <= 0 )
4559			{
4560		✗	Z_scripterrlog("bitmap->Spline() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4561		✗	return;
4562			}
4563
4564		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4565		✗	if ( refbmp == NULL ) return;
4566
4567		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4568
4569		✗	spline(refbmp, points, sdci[10]/10000);
4570
4571		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4572			}
4573
4574
4575		✗	void bmp_do_putpixelr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4576			{
4577			//sdci[1]=layer
4578			//sdci[2]=x
4579			//sdci[3]=y
4580			//sdci[4]=color
4581			//sdci[5]=rotation anchor x
4582			//sdci[6]=rotation anchor y
4583			//sdci[7]=rotation angle
4584			//sdci[8]=opacity
4585			//sdci[17] Bitmap Pointer
4586		✗	int32_t x1=sdci[2]/10000;
4587		✗	int32_t y1=sdci[3]/10000;
4588		✗	int32_t color=sdci[4]/10000;
4589
4590		✗	if(sdci[8]/10000<=127) //translucent
4591			{
4592		✗	drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
4593			}
4594
4595		✗	if ( sdci[17] <= 0 )
4596			{
4597		✗	Z_scripterrlog("bitmap->PutPixel() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4598		✗	return;
4599			}
4600
4601		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4602		✗	if ( refbmp == NULL ) return;
4603
4604		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4605
4606		✗	if(sdci[7]!=0) //rotation
4607			{
4608			int32_t xy[2];
4609		✗	int32_t rx=sdci[5]/10000;
4610		✗	int32_t ry=sdci[6]/10000;
4611		✗	fixed ra1=itofix(sdci[7]%10000)/10000;
4612		✗	fixed ra2=itofix(sdci[7]/10000);
4613		✗	fixed ra=ra1+ra2;
4614
4615		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4616		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4617		✗	x1=xy[0];
4618		✗	y1=xy[1];
4619			}
4620
4621		✗	putpixel(refbmp, x1+xoffset, y1+yoffset, color);
4622		✗	drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
4623			}
4624
4625
4626		✗	void bmp_do_drawtiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4627			{
4628			//sdci[1]=layer
4629			//sdci[2]=x
4630			//sdci[3]=y
4631			//sdci[4]=tile
4632			//sdci[5]=tile width
4633			//sdci[6]=tile height
4634			//sdci[7]=color (cset)
4635			//sdci[8]=scale x
4636			//sdci[9]=scale y
4637			//sdci[10]=rotation anchor x
4638			//sdci[11]=rotation anchor y
4639			//sdci[12]=rotation angle
4640			//sdci[13]=flip
4641			//sdci[14]=transparency
4642			//sdci[15]=opacity
4643			//sdci[17] Bitmap Pointer
4644
4645		✗	int32_t w = sdci[5]/10000;
4646		✗	int32_t h = sdci[6]/10000;
4647
4648		✗	if(w < 1 || h < 1 || h > 20 || w > 20)
4649			{
4650		✗	return;
4651			}
4652
4653		✗	if ( sdci[17] <= 0 )
4654			{
4655		✗	Z_scripterrlog("bitmap->DrawTile() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4656		✗	return;
4657			}
4658
4659		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4660		✗	if ( refbmp == NULL ) return;
4661
4662		✗	int32_t xscale=sdci[8]/10000;
4663		✗	int32_t yscale=sdci[9]/10000;
4664		✗	int32_t rx = sdci[10]/10000;
4665		✗	int32_t ry = sdci[11]/10000;
4666		✗	float rotation=sdci[12]/10000;
4667		✗	int32_t flip=(sdci[13]/10000)&3;
4668		✗	bool transparency=sdci[14]!=0;
4669		✗	int32_t opacity=sdci[15]/10000;
4670		✗	int32_t color=sdci[7]/10000;
4671
4672		✗	int32_t x1=sdci[2]/10000;
4673		✗	int32_t y1=sdci[3]/10000;
4674
4675
4676			//don't scale if it's not safe to do so
4677		✗	bool canscale = true;
4678
4679		✗	if(xscale==0||yscale==0)
4680			{
4681		✗	return;
4682			}
4683
4684		✗	if(xscale<0||yscale<0)
4685		✗	canscale = false; //default size
4686
4687		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4688
4689		✗	if((xscale>0 && yscale>0) || rotation) //scaled or rotated
4690			{
4691		✗	BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16);
4692
4693		✗	if(transparency) //transparency
4694			{
4695		✗	TileHelper::OverTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
4696			}
4697			else //no transparency
4698			{
4699		✗	TileHelper::OldPutTile(pbitty, (sdci[4]/10000), 0, 0, w, h, color, flip);
4700			}
4701
4702		✗	if(rotation != 0)
4703			{
4704			//low negative values indicate no anchor-point rotation
4705		✗	if(rx>-777||ry>-777)
4706			{
4707			int32_t xy[2];
4708		✗	fixed ra1=itofix(sdci[12]%10000)/10000;
4709		✗	fixed ra2=itofix(sdci[12]/10000);
4710		✗	fixed ra=ra1+ra2;
4711		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4712		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4713		✗	x1=xy[0];
4714		✗	y1=xy[1];
4715			}
4716
4717		✗	if(canscale) //scale first
4718			{
4719			//damnit all, .. fixme.
4720		✗	BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
4721		✗	clear_bitmap(tempbit);
4722
4723		✗	stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
4724
4725		✗	if(opacity < 128)
4726			{
4727		✗	clear_bitmap(prim_bmp);
4728		✗	rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
4729		✗	draw_trans_sprite(bmp, prim_bmp, x1+xoffset, y1+yoffset);
4730			}
4731			else
4732			{
4733		✗	rotate_sprite(refbmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4734			}
4735
4736		✗	destroy_bitmap(tempbit);
4737			}
4738			else //no scale
4739			{
4740		✗	if(opacity < 128)
4741			{
4742		✗	clear_bitmap(prim_bmp);
4743		✗	rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
4744		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4745			}
4746			else
4747			{
4748		✗	rotate_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4749			}
4750			}
4751			}
4752			else //scale only
4753			{
4754		✗	if(canscale)
4755			{
4756		✗	if(opacity<128)
4757			{
4758		✗	clear_bitmap(prim_bmp);
4759		✗	stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
4760		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4761			}
4762			else
4763			{
4764		✗	stretch_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
4765			}
4766			}
4767			else //error -do not scale
4768			{
4769		✗	if(opacity<128)
4770			{
4771		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4772			}
4773			else
4774			{
4775		✗	draw_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset);
4776			}
4777			}
4778			}
4779
4780		✗	script_drawing_commands.ReleaseSubBitmap(pbitty);
4781
4782			}
4783			else // no scale or rotation
4784			{
4785		✗	if(transparency)
4786			{
4787		✗	if(opacity<=127)
4788		✗	TileHelper::OverTileTranslucent(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
4789			else
4790		✗	TileHelper::OverTile(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
4791			}
4792			else
4793			{
4794		✗	if(opacity<=127)
4795		✗	TileHelper::PutTileTranslucent(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip, opacity);
4796			else
4797		✗	TileHelper::OldPutTile(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, color, flip);
4798			}
4799			}
4800			}
4801
4802		✗	void bmp_do_drawtilecloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4803			{
4804			//sdci[1]=layer
4805			//sdci[2]=x
4806			//sdci[3]=y
4807			//sdci[4]=tile
4808			//sdci[5]=tile width
4809			//sdci[6]=tile height
4810			//sdci[7]=flip
4811			//sdci[17] Bitmap Pointer
4812
4813		✗	int32_t w = sdci[5]/10000;
4814		✗	int32_t h = sdci[6]/10000;
4815
4816		✗	if(w < 1 || h < 1 || h > 20 || w > 20)
4817			{
4818		✗	return;
4819			}
4820
4821		✗	if ( sdci[17] <= 0 )
4822			{
4823		✗	Z_scripterrlog("bitmap->DrawTileCloaked() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4824		✗	return;
4825			}
4826
4827		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4828		✗	if ( refbmp == NULL ) return;
4829
4830		✗	int32_t flip=(sdci[7]/10000)&3;
4831
4832		✗	int32_t x1=sdci[2]/10000;
4833		✗	int32_t y1=sdci[3]/10000;
4834
4835		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4836
4837		✗	TileHelper::OverTileCloaked(refbmp, (sdci[4]/10000), xoffset+x1, yoffset+y1, w, h, flip);
4838			}
4839
4840
4841		✗	void bmp_do_drawcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
4842			{
4843			//sdci[1]=layer
4844			//sdci[2]=x
4845			//sdci[3]=y
4846			//sdci[4]=combo
4847			//sdci[5]=tile width
4848			//sdci[6]=tile height
4849			//sdci[7]=color (cset)
4850			//sdci[8]=scale x
4851			//sdci[9]=scale y
4852			//sdci[10]=rotation anchor x
4853			//sdci[11]=rotation anchor y
4854			//sdci[12]=rotation angle
4855			//sdci[13]=frame
4856			//sdci[14]=flip
4857			//sdci[15]=transparency
4858			//sdci[16]=opacity
4859			//sdci[17] Bitmap Pointer
4860		✗	int32_t w = sdci[5]/10000;
4861		✗	int32_t h = sdci[6]/10000;
4862
4863		✗	if(w<1||h<1||h>20||w>20)
4864			{
4865		✗	return;
4866			}
4867
4868		✗	if ( sdci[17] <= 0 )
4869			{
4870		✗	Z_scripterrlog("bitmap->DrawCombo() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
4871		✗	return;
4872			}
4873
4874		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
4875		✗	if ( refbmp == NULL ) return;
4876		✗	int32_t cmb = (sdci[4]/10000);
4877		✗	if((unsigned)cmb >= MAXCOMBOS)
4878			{
4879		✗	Z_scripterrlog("DrawCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
4880		✗	return;
4881			}
4882
4883		✗	int32_t xscale=sdci[8]/10000;
4884		✗	int32_t yscale=sdci[9]/10000;
4885		✗	int32_t rx = sdci[10]/10000; //these work now
4886		✗	int32_t ry = sdci[11]/10000; //these work now
4887		✗	float rotation=sdci[12]/10000;
4888
4889		✗	bool transparency=sdci[15]!=0;
4890		✗	int32_t opacity=sdci[16]/10000;
4891		✗	int32_t color=sdci[7]/10000;
4892		✗	int32_t x1=sdci[2]/10000;
4893		✗	int32_t y1=sdci[3]/10000;
4894
4895		✗	const newcombo & c = combobuf[cmb];
4896		✗	int32_t tiletodraw = combo_tile(c, x1, y1);
4897		✗	int32_t flip = ((sdci[14]/10000) & 3) ^ c.flip;
4898		✗	int32_t skiprows=c.skipanimy;
4899
4900
4901			//don't scale if it's not safe to do so
4902		✗	bool canscale = true;
4903
4904		✗	if(xscale==0||yscale==0)
4905			{
4906		✗	return;
4907			}
4908
4909		✗	if(xscale<0||yscale<0)
4910		✗	canscale = false; //default size
4911
4912		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
4913
4914		✗	if((xscale>0 && yscale>0) || rotation) //scaled or rotated
4915			{
4916		✗	BITMAP* pbitty = script_drawing_commands.AquireSubBitmap(w*16, h*16); //-pbitty in the hisouse. :D
4917
4918		✗	if(transparency)
4919			{
4920		✗	TileHelper::OverTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
4921			}
4922			else //no transparency
4923			{
4924		✗	TileHelper::OldPutTile(pbitty, tiletodraw, 0, 0, w, h, color, flip, skiprows);
4925			}
4926
4927		✗	if(rotation != 0) // rotate
4928			{
4929			//fixed point sucks ;0
4930		✗	if(rx>-777||ry>-777) //set the rotation anchor and rotate around that
4931			{
4932			int32_t xy[2];
4933		✗	fixed ra1=itofix(sdci[12]%10000)/10000;
4934		✗	fixed ra2=itofix(sdci[12]/10000);
4935		✗	fixed ra=ra1+ra2;
4936		✗	xy[ 0]=rx + fixtoi((fixcos(ra) * (x1 - rx) - fixsin(ra) * (y1 - ry))); //x1
4937		✗	xy[ 1]=ry + fixtoi((fixsin(ra) * (x1 - rx) + fixcos(ra) * (y1 - ry))); //y1
4938		✗	x1=xy[0];
4939		✗	y1=xy[1];
4940			}
4941
4942		✗	if(canscale) //scale first
4943			{
4944		✗	BITMAP* tempbit = create_bitmap_ex(8, xscale>512?512:xscale, yscale>512?512:yscale);
4945		✗	clear_bitmap(tempbit);
4946
4947		✗	stretch_sprite(tempbit, pbitty, 0, 0, xscale, yscale);
4948
4949		✗	if(opacity < 128)
4950			{
4951		✗	clear_bitmap(prim_bmp);
4952		✗	rotate_sprite(prim_bmp, tempbit, 0, 0, degrees_to_fixed(rotation));
4953		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4954			}
4955			else
4956			{
4957		✗	rotate_sprite(refbmp, tempbit, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4958			}
4959
4960		✗	destroy_bitmap(tempbit);
4961			}
4962			else //no scale
4963			{
4964		✗	if(opacity < 128)
4965			{
4966		✗	clear_bitmap(prim_bmp);
4967		✗	rotate_sprite(prim_bmp, pbitty, 0, 0, degrees_to_fixed(rotation));
4968		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4969			}
4970			else
4971			{
4972		✗	rotate_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, degrees_to_fixed(rotation));
4973			}
4974			}
4975			}
4976			else //scale only
4977			{
4978		✗	if(canscale)
4979			{
4980		✗	if(opacity<128)
4981			{
4982		✗	clear_bitmap(prim_bmp);
4983		✗	stretch_sprite(prim_bmp, pbitty, 0, 0, xscale, yscale);
4984		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4985			}
4986			else
4987			{
4988		✗	stretch_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset, xscale, yscale);
4989			}
4990			}
4991			else //error -do not scale
4992			{
4993		✗	if(opacity<128)
4994			{
4995		✗	draw_trans_sprite(refbmp, prim_bmp, x1+xoffset, y1+yoffset);
4996			}
4997			else
4998			{
4999		✗	draw_sprite(refbmp, pbitty, x1+xoffset, y1+yoffset);
5000			}
5001			}
5002			}
5003
5004		✗	script_drawing_commands.ReleaseSubBitmap(pbitty); //rap sucks
5005			}
5006			else // no scale or rotation
5007			{
5008		✗	if(transparency)
5009			{
5010		✗	if(opacity<=127)
5011		✗	TileHelper::OverTileTranslucent(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
5012			else
5013		✗	TileHelper::OverTile(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
5014			}
5015			else
5016			{
5017		✗	if(opacity<=127)
5018		✗	TileHelper::PutTileTranslucent(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, opacity, skiprows);
5019			else
5020		✗	TileHelper::OldPutTile(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, color, flip, skiprows);
5021			}
5022			}
5023			}
5024
5025
5026		✗	void bmp_do_drawcombocloakedr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5027			{
5028			//sdci[1]=layer
5029			//sdci[2]=x
5030			//sdci[3]=y
5031			//sdci[4]=combo
5032			//sdci[5]=tile width
5033			//sdci[6]=tile height
5034			//sdci[7]=flip
5035			//sdci[17] Bitmap Pointer
5036
5037		✗	int32_t w = sdci[5]/10000;
5038		✗	int32_t h = sdci[6]/10000;
5039
5040		✗	if(w<1||h<1||h>20||w>20)
5041			{
5042		✗	return;
5043			}
5044
5045		✗	if ( sdci[17] <= 0 )
5046			{
5047		✗	Z_scripterrlog("bitmap->DrawComboCloaked() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5048		✗	return;
5049			}
5050
5051		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5052		✗	if ( refbmp == NULL ) return;
5053		✗	int32_t cmb = (sdci[4]/10000);
5054		✗	if((unsigned)cmb >= MAXCOMBOS)
5055			{
5056		✗	Z_scripterrlog("DrawComboCloaked() cannot draw combo '%d', as it is out of bounds.\n", cmb);
5057		✗	return;
5058			}
5059
5060		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5061
5062		✗	int32_t x1=sdci[2]/10000;
5063		✗	int32_t y1=sdci[3]/10000;
5064
5065		✗	const newcombo & c = combobuf[cmb];
5066		✗	int32_t tiletodraw = combo_tile(c, x1, y1);
5067		✗	int32_t flip = ((sdci[7]/10000) & 3) ^ c.flip;
5068		✗	int32_t skiprows=c.skipanimy;
5069
5070		✗	TileHelper::OverTileCloaked(refbmp, tiletodraw, xoffset+x1, yoffset+y1, w, h, flip, skiprows);
5071			}
5072
5073
5074		✗	void bmp_do_fasttiler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5075			{
5076			/* layer, x, y, tile, color opacity */
5077			//sdci[17] Bitmap Pointer
5078
5079		✗	int32_t opacity = sdci[6]/10000;
5080		✗	if ( sdci[17] <= 0 )
5081			{
5082		✗	Z_scripterrlog("bitmap->FastTile() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5083		✗	return;
5084			}
5085		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5086		✗	if ( refbmp == NULL ) return;
5087
5088		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5089
5090		✗	if(opacity < 128)
5091		✗	overtiletranslucent16(refbmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0, opacity);
5092			else
5093		✗	overtile16(refbmp, sdci[4]/10000, xoffset+(sdci[2]/10000), yoffset+(sdci[3]/10000), sdci[5]/10000, 0);
5094			}
5095
5096		✗	void do_bmpwritetile(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5097			{
5098			/* layer, x, y, tile, is8bit, mask */
5099			//sdci[17] Bitmap Pointer
5100		✗	if ( sdci[17] <= 0 )
5101			{
5102		✗	Z_scripterrlog("bitmap->WriteTile() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5103		✗	return;
5104			}
5105		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5106		✗	if ( refbmp == NULL ) return;
5107
5108		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5109
5110		✗	int32_t x = (sdci[2]/10000), y = (sdci[3]/10000), tl = (sdci[4]/10000);
5111		✗	bool is8bit = sdci[5]!=0, mask = sdci[6]!=0;
5112
5113		✗	write_tile(newtilebuf, refbmp, tl, x+xoffset, y+yoffset, is8bit, mask);
5114			}
5115
5116		✗	void do_bmpdither(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5117			{
5118			/* layer, mask, color, ditherType, ditherArg */
5119			//sdci[2] Mask Bitmap Pointer
5120			//sdci[3] Color
5121			//sdci[17] Bitmap Pointer
5122		✗	if ( sdci[17] <= 0 )
5123			{
5124		✗	Z_scripterrlog("bitmap->Dither() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5125		✗	return;
5126			}
5127		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5128		✗	if ( refbmp == NULL ) return;
5129		✗	if ( sdci[2] <= 0 )
5130			{
5131		✗	Z_scripterrlog("bitmap->Dither() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[2]);
5132		✗	return;
5133			}
5134		✗	BITMAP *mask = FFCore.GetScriptBitmap(sdci[2]-10);
5135		✗	if ( mask == NULL ) return;
5136
5137		✗	int32_t dType = sdci[4] / 10000L;
5138		✗	if(dType < 0 || dType >= dithMax)
5139			{
5140		✗	Z_scripterrlog("bitmap->Dither() used an invalid dither type: %d. Aborting.\n", dType);
5141		✗	return;
5142			}
5143
5144		✗	ditherblit(refbmp, mask, byte(sdci[3]/10000L), dType, sdci[5]/10000L);
5145			}
5146
5147		✗	void do_bmpreplcol(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5148			{
5149			/* layer, shift, startcol, endcol */
5150			//sdci[2] NewCol
5151			//sdci[3] StartCol
5152			//sdci[4] EndCol
5153			//sdci[17] Bitmap Pointer
5154		✗	if ( sdci[17] <= 0 )
5155			{
5156		✗	Z_scripterrlog("bitmap->ReplaceColors() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5157		✗	return;
5158			}
5159		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5160		✗	if ( refbmp == NULL ) return;
5161		✗	replColor(refbmp, sdci[2]/10000L, sdci[3]/10000L, sdci[4]/10000L, false);
5162			}
5163
5164		✗	void do_bmpshiftcol(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5165			{
5166			/* layer, shift, startcol, endcol */
5167			//sdci[2] ShiftAmount
5168			//sdci[3] StartCol
5169			//sdci[4] EndCol
5170			//sdci[17] Bitmap Pointer
5171		✗	if ( sdci[17] <= 0 )
5172			{
5173		✗	Z_scripterrlog("bitmap->ShiftColors() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5174		✗	return;
5175			}
5176		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5177		✗	if ( refbmp == NULL ) return;
5178		✗	replColor(refbmp, sdci[2]/10000L, sdci[3]/10000L, sdci[4]/10000L, true);
5179			}
5180
5181		✗	void do_bmpmaskdraw(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5182			{
5183			/* layer, mask, color */
5184			//sdci[2] Mask Bitmap Pointer
5185			//sdci[3] Color
5186			//sdci[4] start mask color
5187			//sdci[5] end mask color
5188			//sdci[17] Bitmap Pointer
5189		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5190		✗	if ( refbmp == NULL )
5191			{
5192		✗	Z_scripterrlog("bitmap->MaskDraw() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5193		✗	return;
5194			}
5195		✗	BITMAP *mask = FFCore.GetScriptBitmap(sdci[2]-10);
5196		✗	if ( mask == NULL )
5197			{
5198		✗	Z_scripterrlog("bitmap->MaskDraw() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[2]);
5199		✗	return;
5200			}
5201		✗	auto fillcol = sdci[3]/10000L;
5202		✗	if(unsigned(fillcol) > 0xFF) return; //invalid color, nothing to draw
5203		✗	auto startcol = vbound(sdci[4]/10000L,0x00,0xFF);
5204		✗	auto endcol = vbound(sdci[5]/10000L,0x00,0xFF);
5205		✗	mask_colorfill(refbmp, mask, fillcol, startcol, endcol);
5206			}
5207
5208		✗	void do_bmpmaskblit(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5209			{
5210			/* layer, mask, color */
5211			//sdci[2] Mask Bitmap Pointer
5212			//sdci[3] Pattern Bitmap
5213			//sdci[4] bool 'pattern repeats'
5214			//sdci[5] start mask color
5215			//sdci[6] end mask color
5216			//sdci[17] Bitmap Pointer
5217		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5218		✗	if ( refbmp == NULL )
5219			{
5220		✗	Z_scripterrlog("bitmap->MaskDraw() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5221		✗	return;
5222			}
5223		✗	BITMAP *mask = FFCore.GetScriptBitmap(sdci[2]-10);
5224		✗	if ( mask == NULL )
5225			{
5226		✗	Z_scripterrlog("bitmap->MaskDraw() wanted to read from an invalid bitmap (mask) id: %d. Aborting.\n", sdci[2]);
5227		✗	return;
5228			}
5229		✗	BITMAP *pattern = FFCore.GetScriptBitmap(sdci[3]-10);
5230		✗	if ( pattern == NULL )
5231			{
5232		✗	Z_scripterrlog("bitmap->MaskDraw() wanted to read from an invalid bitmap (pattern) id: %d. Aborting.\n", sdci[3]);
5233		✗	return;
5234			}
5235		✗	bool repeats = sdci[4]!=0;
5236		✗	auto startcol = vbound(sdci[5]/10000L,0x00,0xFF);
5237		✗	auto endcol = vbound(sdci[6]/10000L,0x00,0xFF);
5238		✗	mask_blit(refbmp, mask, pattern, repeats, startcol, endcol);
5239			}
5240
5241		✗	void bmp_do_fastcombor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5242			{
5243			/* layer, x, y, tile, color opacity */
5244			//sdci[17] Bitmap Pointer
5245		✗	int32_t opacity = sdci[6] / 10000;
5246		✗	int32_t x1 = sdci[2] / 10000;
5247		✗	int32_t y1 = sdci[3] / 10000;
5248		✗	int32_t index = sdci[4]/10000;
5249		✗	if ( sdci[17] <= 0 )
5250			{
5251		✗	Z_scripterrlog("bitmap->FastCombo() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5252		✗	return;
5253			}
5254		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5255		✗	if ( refbmp == NULL ) return;
5256		✗	int32_t cmb = (sdci[4]/10000);
5257		✗	if((unsigned)cmb >= MAXCOMBOS)
5258			{
5259		✗	Z_scripterrlog("FastCombo() cannot draw combo '%d', as it is out of bounds.\n", cmb);
5260		✗	return;
5261			}
5262
5263		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5264
5265			//if( index >= MAXCOMBOS ) return; //bleh.
5266			/*
5267			const newcombo & c = combobuf[index];
5268
5269			if(opacity < 128)
5270			overtiletranslucent16(refbmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip, opacity);
5271			else
5272			overtile16(refbmp, combo_tile(c, x1, y1), xoffset+x1, yoffset+y1, sdci[5]/10000, (int32_t)c.flip);
5273			*/
5274
5275		✗	if(opacity < 128)
5276			{
5277			//void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
5278		✗	overcomboblocktranslucent(refbmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1, 128);
5279
5280			}
5281			else
5282			{
5283			//overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
5284		✗	overcomboblock(refbmp, xoffset+x1, yoffset+y1, cmb, sdci[5]/10000, 1, 1);
5285			}
5286			}
5287
5288
5289
5290		✗	void bmp_do_drawcharr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5291			{
5292			//sdci[17] Bitmap Pointer
5293		✗	if ( sdci[17] <= 0 )
5294			{
5295		✗	Z_scripterrlog("bitmap->DrawCharacter() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5296		✗	return;
5297			}
5298		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5299		✗	if ( refbmp == NULL ) return;
5300
5301		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5302
5303			//broken 2.50.2 and earlier drawcharacter()
5304		✗	if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
5305			{
5306			//sdci[1]=layer
5307			//sdci[2]=x
5308			//sdci[3]=y
5309			//sdci[4]=font
5310			//sdci[5]=color
5311			//sdci[6]=bg color
5312			//sdci[7]=strech x (width)
5313			//sdci[8]=stretch y (height)
5314			//sdci[9]=char
5315			//sdci[10]=opacity
5316			//sdci[17] Bitmap Pointer
5317
5318		✗	int32_t x=sdci[2]/10000;
5319		✗	int32_t y=sdci[3]/10000;
5320		✗	int32_t font_index=sdci[4]/10000;
5321		✗	int32_t color=sdci[5]/10000;
5322		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
5323		✗	int32_t w=sdci[7]/10000;
5324		✗	int32_t h=sdci[8]/10000;
5325		✗	char glyph=char(sdci[9]/10000);
5326		✗	int32_t opacity=sdci[10]/10000;
5327
5328			//safe check
5329		✗	if(bg_color < -1) bg_color = -1;
5330
5331		✗	if(w>512) w=512; //w=vbound(w,0,512);
5332
5333		✗	if(h>512) h=512; //h=vbound(h,0,512);
5334
5335			//undone
5336		✗	if(w>0&&h>0)//stretch the character
5337			{
5338		✗	BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
5339
5340		✗	if(opacity < 128)
5341			{
5342		✗	if(w>128||h>128)
5343			{
5344		✗	clear_bitmap(prim_bmp);
5345
5346		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5347		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5348		✗	draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5349			}
5350			else //this is faster
5351			{
5352		✗	BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
5353
5354		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5355		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5356		✗	draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5357
5358		✗	script_drawing_commands.ReleaseSubBitmap(pbmp2);
5359			}
5360			}
5361			else // no opacity
5362			{
5363		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5364		✗	stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5365			}
5366
5367			}
5368			else //no stretch
5369			{
5370		✗	if(opacity < 128)
5371			{
5372		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
5373		✗	clear_bitmap(pbmp);
5374
5375		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5376		✗	draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5377
5378		✗	destroy_bitmap(pbmp);
5379			}
5380			else // no opacity
5381			{
5382		✗	textprintf_ex(refbmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
5383			}
5384			}
5385			}
5386
5387			else //2.53.0 fixed version and later.
5388			{
5389
5390			//sdci[1]=layer
5391			//sdci[2]=x
5392			//sdci[3]=y
5393			//sdci[4]=font
5394			//sdci[5]=color
5395			//sdci[6]=bg color
5396			//sdci[7]=strech x (width)
5397			//sdci[8]=stretch y (height)
5398			//sdci[9]=char
5399			//sdci[10]=opacity
5400
5401		✗	int32_t x=sdci[2]/10000;
5402		✗	int32_t y=sdci[3]/10000;
5403		✗	int32_t font_index=sdci[4]/10000;
5404		✗	int32_t color=sdci[5]/10000;
5405		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
5406		✗	int32_t w=sdci[7]/10000;
5407		✗	int32_t h=sdci[8]/10000;
5408		✗	char glyph=char(sdci[9]/10000);
5409		✗	int32_t opacity=sdci[10]/10000;
5410
5411			//safe check
5412		✗	if(bg_color < -1) bg_color = -1;
5413
5414		✗	if(w>512) w=512; //w=vbound(w,0,512);
5415
5416		✗	if(h>512) h=512; //h=vbound(h,0,512);
5417
5418			//undone
5419		✗	if(w>0&&h>0)//stretch the character
5420			{
5421		✗	BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
5422
5423		✗	if(opacity < 128)
5424			{
5425		✗	if(w>128||h>128)
5426			{
5427		✗	clear_bitmap(prim_bmp);
5428
5429		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5430		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5431		✗	draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5432			}
5433			else //this is faster
5434			{
5435		✗	BITMAP *pbmp2 = script_drawing_commands.AquireSubBitmap(w,h);
5436
5437		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5438		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5439		✗	draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5440
5441		✗	script_drawing_commands.ReleaseSubBitmap(pbmp2);
5442			}
5443			}
5444			else // no opacity
5445			{
5446		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5447		✗	stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5448			}
5449
5450			}
5451			else //no stretch
5452			{
5453		✗	if(opacity < 128)
5454			{
5455		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
5456		✗	clear_bitmap(pbmp);
5457
5458		✗	textprintf_ex(pbmp, get_zc_font(font_index), 0, 0, color, bg_color, "%c", glyph);
5459		✗	draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5460
5461		✗	destroy_bitmap(pbmp);
5462			}
5463			else // no opacity
5464			{
5465		✗	textprintf_ex(refbmp, get_zc_font(font_index), x+xoffset, y+yoffset, color, bg_color, "%c", glyph);
5466			}
5467			}
5468
5469			}
5470
5471			}
5472
5473
5474		✗	void bmp_do_drawintr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5475			{
5476		✗	if ( sdci[17] <= 0 )
5477			{
5478		✗	Z_scripterrlog("bitmap->DrawInteger() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5479		✗	return;
5480			}
5481		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5482		✗	if ( refbmp == NULL ) return;
5483
5484		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5485
5486			//broken 2.50.2 and earlier drawinteger()
5487		✗	if ( get_bit(quest_rules, qr_BROKENCHARINTDRAWING) )
5488			{
5489			//sdci[1]=layer
5490			//sdci[2]=x
5491			//sdci[3]=y
5492			//sdci[4]=font
5493			//sdci[5]=color
5494			//sdci[6]=bg color
5495			//sdci[7]=strech x (width)
5496			//sdci[8]=stretch y (height)
5497			//sdci[9]=integer
5498			//sdci[10]=num decimal places
5499			//sdci[11]=opacity
5500			//sdci[17] Bitmap Pointer
5501
5502		✗	int32_t x=sdci[2]/10000;
5503		✗	int32_t y=sdci[3]/10000;
5504		✗	int32_t font_index=sdci[4]/10000;
5505		✗	int32_t color=sdci[5]/10000;
5506		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
5507		✗	int32_t w=sdci[7]/10000;
5508		✗	int32_t h=sdci[8]/10000;
5509			//float number=static_cast<float>(sdci[9])/10000.0f;
5510		✗	int32_t decplace=sdci[10]/10000;
5511		✗	int32_t opacity=sdci[11]/10000;
5512
5513			//safe check
5514		✗	if(bg_color < -1) bg_color = -1;
5515
5516		✗	if(w>512) w=512; //w=vbound(w,0,512);
5517
5518		✗	if(h>512) h=512; //h=vbound(h,0,512);
5519
5520			char numbuf[15];
5521
5522		✗	switch(decplace)
5523			{
5524			default:
5525			case 0:
5526		✗	sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
5527		✗	break; //reducing the value by -1, so 8.000 printed as '7'. -Z
5528
5529			case 1:
5530			//sprintf(numbuf,"%.01f",number);
5531		✗	sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
5532		✗	break;
5533
5534			case 2:
5535			//sprintf(numbuf,"%.02f",number);
5536		✗	sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
5537		✗	break;
5538
5539			case 3:
5540			//sprintf(numbuf,"%.03f",number);
5541		✗	sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
5542		✗	break;
5543
5544			case 4:
5545			//sprintf(numbuf,"%.04f",number);
5546		✗	sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
5547		✗	break;
5548			}
5549
5550		✗	if(w>0&&h>0)//stretch
5551			{
5552		✗	BITMAP *pbmp = script_drawing_commands.GetSmallTextureBitmap(1,1);
5553
5554		✗	if(opacity < 128)
5555			{
5556		✗	if(w>128||h>128)
5557			{
5558		✗	clear_bitmap(prim_bmp);
5559
5560		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5561		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5562		✗	draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5563			}
5564			else
5565			{
5566		✗	BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
5567		✗	clear_bitmap(pbmp2);
5568
5569		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5570		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5571		✗	draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5572
5573		✗	destroy_bitmap(pbmp2);
5574			}
5575			}
5576			else // no opacity
5577			{
5578		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5579		✗	stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5580			}
5581
5582			}
5583			else //no stretch
5584			{
5585		✗	if(opacity < 128)
5586			{
5587		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp,0,0,16,16);
5588		✗	clear_bitmap(pbmp);
5589
5590		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5591		✗	draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5592
5593		✗	destroy_bitmap(pbmp);
5594			}
5595			else // no opacity
5596			{
5597		✗	textout_ex(refbmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
5598			}
5599			}
5600
5601			}
5602
5603			else //2.53.0 fixed version and later.
5604			{
5605			//sdci[1]=layer
5606			//sdci[2]=x
5607			//sdci[3]=y
5608			//sdci[4]=font
5609			//sdci[5]=color
5610			//sdci[6]=bg color
5611			//sdci[7]=strech x (width)
5612			//sdci[8]=stretch y (height)
5613			//sdci[9]=integer
5614			//sdci[10]=num decimal places
5615			//sdci[11]=opacity
5616
5617		✗	int32_t x=sdci[2]/10000;
5618		✗	int32_t y=sdci[3]/10000;
5619		✗	int32_t font_index=sdci[4]/10000;
5620		✗	int32_t color=sdci[5]/10000;
5621		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
5622		✗	int32_t w=sdci[7]/10000;
5623		✗	int32_t h=sdci[8]/10000;
5624			//float number=static_cast<float>(sdci[9])/10000.0f;
5625			//int32_t numberint = sdci[9]/10000;
5626		✗	int32_t decplace=sdci[10]/10000;
5627		✗	int32_t opacity=sdci[11]/10000;
5628
5629			//safe check
5630		✗	if(bg_color < -1) bg_color = -1;
5631
5632		✗	if(w>512) w=512; //w=vbound(w,0,512);
5633
5634		✗	if(h>512) h=512; //h=vbound(h,0,512);
5635
5636			char numbuf[15];
5637
5638		✗	switch(decplace)
5639			{
5640			default:
5641			case 0:
5642		✗	sprintf(numbuf,"%d",(sdci[9]/10000)); //For some reason, static casting for zero decimal places was
5643		✗	break; //reducing the value by -1, so 8.000 printed as '7'. -Z
5644
5645			case 1:
5646			//sprintf(numbuf,"%.01f",number);
5647		✗	sprintf(numbuf,"%.01f",(static_cast<float>(sdci[9])/10000.0f)); //Would this be slower?
5648		✗	break;
5649
5650			case 2:
5651			//sprintf(numbuf,"%.02f",number);
5652		✗	sprintf(numbuf,"%.02f",(static_cast<float>(sdci[9])/10000.0f));
5653		✗	break;
5654
5655			case 3:
5656			//sprintf(numbuf,"%.03f",number);
5657		✗	sprintf(numbuf,"%.03f",(static_cast<float>(sdci[9])/10000.0f));
5658		✗	break;
5659
5660			case 4:
5661			//sprintf(numbuf,"%.04f",number);
5662		✗	sprintf(numbuf,"%.04f",(static_cast<float>(sdci[9])/10000.0f));
5663		✗	break;
5664			}
5665
5666			//FONT* font=get_zc_font(sdci[4]/10000);
5667
5668		✗	if(w>0&&h>0)//stretch
5669			{
5670		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(get_zc_font(font_index), numbuf)+1, text_height(get_zc_font(font_index)));
5671		✗	clear_bitmap(pbmp);
5672			//script_drawing_commands.GetSmallTextureBitmap(1,1);
5673
5674		✗	if(opacity < 128)
5675			{
5676		✗	if(w>128||h>128)
5677			{
5678		✗	clear_bitmap(prim_bmp);
5679
5680		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5681		✗	stretch_sprite(prim_bmp, pbmp, 0, 0, w, h);
5682		✗	draw_trans_sprite(refbmp, prim_bmp, x+xoffset, y+yoffset);
5683			}
5684			else
5685			{
5686		✗	BITMAP *pbmp2 = create_sub_bitmap(prim_bmp,0,0,w,h);
5687		✗	clear_bitmap(pbmp2);
5688
5689		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5690		✗	stretch_sprite(pbmp2, pbmp, 0, 0, w, h);
5691		✗	draw_trans_sprite(refbmp, pbmp2, x+xoffset, y+yoffset);
5692
5693		✗	destroy_bitmap(pbmp2);
5694			}
5695			}
5696			else // no opacity
5697			{
5698		✗	textout_ex(pbmp, get_zc_font(font_index), numbuf, 0, 0, color, bg_color);
5699		✗	stretch_sprite(refbmp, pbmp, x+xoffset, y+yoffset, w, h);
5700			}
5701
5702			}
5703			else //no stretch
5704			{
5705		✗	if(opacity < 128)
5706			{
5707		✗	FONT* font = get_zc_font(font_index);
5708		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, text_length(font, numbuf), text_height(font));
5709		✗	clear_bitmap(pbmp);
5710
5711		✗	textout_ex(pbmp, font, numbuf, 0, 0, color, bg_color);
5712		✗	draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5713
5714		✗	destroy_bitmap(pbmp);
5715			}
5716			else // no opacity
5717			{
5718		✗	textout_ex(refbmp, get_zc_font(font_index), numbuf, x+xoffset, y+yoffset, color, bg_color);
5719			}
5720			}
5721			}
5722			}
5723
5724
5725		✗	void bmp_do_drawstringr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5726			{
5727			//sdci[1]=layer
5728			//sdci[2]=x
5729			//sdci[3]=y
5730			//sdci[4]=font
5731			//sdci[5]=color
5732			//sdci[6]=bg color
5733			//sdci[7]=format_option
5734			//sdci[8]=string
5735			//sdci[9]=opacity
5736			//sdci[17] Bitmap Pointer
5737		✗	if ( sdci[17] <= 0 )
5738			{
5739		✗	Z_scripterrlog("bitmap->DrawString() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5740		✗	return;
5741			}
5742
5743		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5744		✗	if ( refbmp == NULL ) return;
5745
5746		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5747
5748		✗	std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
5749
5750		✗	if(!str)
5751			{
5752		✗	al_trace("String pointer is null! Internal error. \n");
5753		✗	return;
5754			}
5755
5756		✗	int32_t x=sdci[2]/10000;
5757		✗	int32_t y=sdci[3]/10000;
5758		✗	FONT* font=get_zc_font(sdci[4]/10000);
5759		✗	int32_t color=sdci[5]/10000;
5760		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
5761		✗	int32_t format_type=sdci[7]/10000;
5762		✗	int32_t opacity=sdci[9]/10000;
5763			//sdci[8] not needed :)
5764
5765			//safe check
5766		✗	if(bg_color < -1) bg_color = -1;
5767
5768		✗	if(opacity < 128)
5769			{
5770		✗	int32_t width=zc_min(text_length(font, str->c_str()), 512);
5771		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
5772		✗	clear_bitmap(pbmp);
5773		✗	textout_ex(pbmp, font, str->c_str(), 0, 0, color, bg_color);
5774		✗	if(format_type == 2) // right-sided text
5775		✗	x-=width;
5776		✗	else if(format_type == 1) // centered text
5777		✗	x-=width/2;
5778		✗	draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5779		✗	destroy_bitmap(pbmp);
5780			}
5781			else // no opacity
5782			{
5783		✗	if(format_type == 2) // right-sided text
5784			{
5785		✗	textout_right_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
5786			}
5787		✗	else if(format_type == 1) // centered text
5788			{
5789		✗	textout_centre_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
5790			}
5791			else // standard left-sided text
5792			{
5793		✗	textout_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, color, bg_color);
5794			}
5795			}
5796			}
5797
5798		✗	void bmp_do_drawstringr2(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5799			{
5800			//sdci[1]=layer
5801			//sdci[2]=x
5802			//sdci[3]=y
5803			//sdci[4]=font
5804			//sdci[5]=color
5805			//sdci[6]=bg color
5806			//sdci[7]=format_option
5807			//sdci[8]=string
5808			//sdci[9]=opacity
5809			//sdci[10]=shadowtype
5810			//sdci[11]=shadow_color
5811			//sdci[17] Bitmap Pointer
5812		✗	if ( sdci[17] <= 0 )
5813			{
5814		✗	Z_scripterrlog("bitmap->DrawString() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5815		✗	return;
5816			}
5817
5818		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
5819		✗	if ( refbmp == NULL ) return;
5820
5821		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
5822
5823		✗	std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
5824
5825		✗	if(!str)
5826			{
5827		✗	al_trace("String pointer is null! Internal error. \n");
5828		✗	return;
5829			}
5830
5831		✗	int32_t x=sdci[2]/10000;
5832		✗	int32_t y=sdci[3]/10000;
5833		✗	FONT* font=get_zc_font(sdci[4]/10000);
5834		✗	int32_t color=sdci[5]/10000;
5835		✗	int32_t bg_color=sdci[6]/10000; //-1 = transparent
5836		✗	int32_t format_type=sdci[7]/10000;
5837		✗	int32_t opacity=sdci[9]/10000;
5838		✗	int32_t textstyle = sdci[10]/10000;
5839		✗	int32_t shadow_color = sdci[11]/10000;
5840			//sdci[8] not needed :)
5841
5842			//safe check
5843		✗	if(bg_color < -1) bg_color = -1;
5844
5845		✗	if(opacity < 128)
5846			{
5847		✗	int32_t width=zc_min(text_length(font, str->c_str()), 512);
5848		✗	BITMAP *pbmp = create_sub_bitmap(prim_bmp, 0, 0, width, text_height(font));
5849		✗	clear_bitmap(pbmp);
5850		✗	textout_styled_aligned_ex(pbmp, font, str->c_str(), 0, 0, textstyle, sstaLEFT, color, shadow_color, bg_color);
5851		✗	if(format_type == 2) // right-sided text
5852		✗	x-=width;
5853		✗	else if(format_type == 1) // centered text
5854		✗	x-=width/2;
5855		✗	draw_trans_sprite(refbmp, pbmp, x+xoffset, y+yoffset);
5856		✗	destroy_bitmap(pbmp);
5857			}
5858			else // no opacity
5859			{
5860		✗	textout_styled_aligned_ex(refbmp, font, str->c_str(), x+xoffset, y+yoffset, textstyle, format_type, color, shadow_color, bg_color);
5861			}
5862			}
5863
5864		✗	void bmp_do_clearr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5865			{
5866			//sdci[1]=layer
5867			//sdci[17] Bitmap Pointer
5868			//Z_scripterrlog("bitmap->Clear() pointer is: %d\n", sdci[17]);
5869		✗	if ( sdci[17] <= 0 )
5870			{
5871		✗	Z_scripterrlog("bitmap->Clear() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5872		✗	return;
5873			}
5874		✗	int32_t bitid = sdci[17] - 10;
5875		✗	if ( scb.script_created_bitmaps[bitid].u_bmp )
5876		✗	clear_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5877			}
5878
5879		✗	void bmp_do_clearcolorr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5880			{
5881			//sdci[1]=layer
5882			//sdci[2]=color
5883			//sdci[17] Bitmap Pointer
5884		✗	int32_t pal_color = sdci[2]/10000;
5885		✗	if ( sdci[17] <= 0 )
5886			{
5887		✗	Z_scripterrlog("bitmap->ClearToColor() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5888		✗	return;
5889			}
5890		✗	int32_t bitid = sdci[17] - 10;
5891		✗	if ( scb.script_created_bitmaps[bitid].u_bmp )
5892		✗	clear_to_color(scb.script_created_bitmaps[bitid].u_bmp, pal_color);
5893			}
5894
5895
5896		✗	void bmp_do_regenr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5897			{
5898			//sdci[1]=layer
5899		✗	int32_t h = sdci[3]/10000;
5900		✗	int32_t w = sdci[2]/10000;
5901		✗	if ( get_bit(quest_rules, qr_OLDCREATEBITMAP_ARGS) )
5902			{
5903			//flip height and width
5904		✗	h = h ^ w;
5905		✗	w = h ^ w;
5906		✗	h = h ^ w;
5907			}
5908			//sdci[17] Bitmap Pointer
5909			//Z_scripterrlog("bitmap->Create() pointer is: %d\n", sdci[17]);
5910		✗	if ( sdci[17] <= 0 )
5911			{
5912		✗	Z_scripterrlog("bitmap->Create() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5913		✗	return;
5914			}
5915		✗	int32_t bitid = sdci[17] - 10;
5916		✗	if ( scb.script_created_bitmaps[bitid].u_bmp )
5917		✗	destroy_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5918		✗	scb.script_created_bitmaps[bitid].u_bmp = create_bitmap_ex(8,w,h);
5919
5920		✗	scb.script_created_bitmaps[bitid].width = w;
5921		✗	scb.script_created_bitmaps[bitid].height = h;
5922
5923
5924
5925			}
5926
5927		✗	void bmp_do_readr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5928			{
5929			//sdci[1]=layer
5930			//sdci[2]=filename
5931			//sdci[3]=y
5932			//sdci[4]=font
5933			//sdci[5]=color
5934			//sdci[6]=bg color
5935			//sdci[7]=format_option
5936			//sdci[8]=string
5937			//sdci[9]=opacity
5938			//sdci[17] Bitmap Pointer
5939			//Z_scripterrlog("bitmap->Read() pointer is: %d\n", sdci[17]);
5940		✗	if ( sdci[17] <= 0 )
5941			{
5942		✗	Z_scripterrlog("bitmap->Read() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
5943		✗	return;
5944			}
5945		✗	int32_t bitid = sdci[17] - 10;
5946		✗	scb.script_created_bitmaps[bitid].destroy();
5947
5948		✗	std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
5949
5950			//char *cptr = new char[str->size()+1]; // +1 to account for \0 byte
5951			// std::strncpy(cptr, str->c_str(), str->size());
5952			// Z_scripterrlog("The following should be the filename string:\n");
5953			//Z_scripterrlog(" %s\n", cptr);
5954
5955		✗	if(!str)
5956			{
5957		✗	al_trace("String pointer is null! Internal error. \n");
5958		✗	return;
5959			}
5960
5961			// Z_scripterrlog("Trying to read filename %s\n", cptr);
5962			PALETTE tempPal;
5963		✗	get_palette(tempPal);
5964		✗	if ( checkPath(str->c_str(), false) )
5965			{
5966		✗	scb.script_created_bitmaps[bitid].u_bmp = load_bitmap(str->c_str(), tempPal);
5967		✗	scb.script_created_bitmaps[bitid].width = scb.script_created_bitmaps[bitid].u_bmp->w;
5968		✗	scb.script_created_bitmaps[bitid].height = scb.script_created_bitmaps[bitid].u_bmp->h;
5969		✗	if ( !scb.script_created_bitmaps[bitid].u_bmp )
5970			{
5971		✗	Z_scripterrlog("Failed to load image file %s.\nMaking a blank bitmap on the pointer.\n", str->c_str());
5972			//scb.script_created_bitmaps[bitid].u_bmp = create_bitmap_ex(8,256,176);
5973			//clear_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5974			}
5975			else
5976			{
5977		✗	zprint("Read image file %s\n",str->c_str());
5978			}
5979			}
5980			else
5981			{
5982		✗	Z_scripterrlog("Failed to load image file: %s. File not found. Creating a blank bitmap on the pointer.\n", str->c_str());
5983		✗	scb.script_created_bitmaps[bitid].u_bmp = create_bitmap_ex(8,256,176);
5984		✗	clear_bitmap(scb.script_created_bitmaps[bitid].u_bmp);
5985			}
5986			}
5987
5988
5989
5990		✗	void bmp_do_writer(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
5991			{
5992			//sdci[1]=layer
5993			//sdci[2]=filename
5994			//sdci[3]=y
5995			//sdci[4]=font
5996			//sdci[5]=color
5997			//sdci[6]=bg color
5998			//sdci[7]=format_option
5999			//sdci[8]=string
6000			//sdci[9]=opacity
6001			//sdci[17] Bitmap Pointer
6002			//Z_scripterrlog("bitmap->Write() pointer is: %d\n", sdci[17]);
6003
6004		✗	if ( sdci[17] <= 0 )
6005			{
6006		✗	Z_scripterrlog("bitmap->Write() wanted to use to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6007		✗	return;
6008			}
6009		✗	int32_t bitid = sdci[17] - 10;
6010
6011		✗	if ( !scb.script_created_bitmaps[bitid].u_bmp )
6012			{
6013		✗	Z_scripterrlog("Tried to write from an invalid bitmap pointer %d. Aborting. \n", sdci[17]);
6014		✗	return;
6015			}
6016
6017		✗	bool overwrite = (sdci[3] != 0);
6018		✗	std::string* str = (std::string*)script_drawing_commands[i].GetPtr();
6019
6020		✗	if(!str)
6021			{
6022		✗	al_trace("String pointer is null! Internal error. \n");
6023		✗	return;
6024			}
6025
6026			//char *cptr = new char[str->size()+1]; // +1 to account for \0 byte
6027			//std::strncpy(cptr, str->c_str(), str->size());
6028			//Z_scripterrlog("bitmap->Write extension matches ? : %s\n!", (FFCore.checkExtension(str->c_str(), ".png")) ? "true" : "false");
6029			//Z_scripterrlog("Trying to write filename %s\n", cptr);
6030			if
6031			(
6032		✗	( (FFCore.checkExtension(*str, "")) ) ||
6033		✗	( !(FFCore.checkExtension(*str, ".png")) && !(FFCore.checkExtension(*str, ".gif")) && !(FFCore.checkExtension(*str, ".bmp"))
6034		✗	&& !(FFCore.checkExtension(*str, ".pcx")) && !(FFCore.checkExtension(*str, ".tga")) )
6035			)
6036			{
6037		✗	Z_scripterrlog("No extension, or invalid extension provided for writing bitmap file %s. Could not write the file.\nValid types are .png, .gif, .pcx, .tgx, and .bmp. Aborting.\n",str->c_str());
6038			}
6039		✗	else if ( overwrite || (!checkPath(str->c_str(), false)) )
6040			{
6041		✗	if(create_path(str->c_str()))
6042			{
6043		✗	save_bitmap(str->c_str(), scb.script_created_bitmaps[bitid].u_bmp, RAMpal);
6044		✗	if(checkPath(str->c_str(), false))
6045			{
6046		✗	zprint("Wrote image file %s\n",str->c_str());
6047			}
6048			else
6049			{
6050		✗	Z_scripterrlog("Failed to create file '%s'\n",str->c_str());
6051			}
6052			}
6053			else
6054			{
6055		✗	Z_scripterrlog("Cannot write file '%s' because the directory does not exist, and could not be created.\n", str->c_str());
6056			}
6057			}
6058		✗	else Z_scripterrlog("Cannot write file '%s' because the file already exists in the specified path.\n", str->c_str());
6059			}
6060
6061
6062		✗	void bmp_do_drawquadr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6063			{
6064			//sdci[1]=layer
6065			//sdci[2]=x1
6066			//sdci[3]=y1
6067			//sdci[4]=x2
6068			//sdci[5]=y2
6069			//sdci[6]=x3
6070			//sdci[7]=y3
6071			//sdci[8]=x4
6072			//sdci[9]=y4
6073			//sdci[10]=width
6074			//sdci[11]=height
6075			//sdci[12]=cset
6076			//sdci[13]=flip
6077			//sdci[14]=tile/combo
6078			//sdci[15]=polytype
6079			//sdci[16] = other bitmap as texture
6080			//sdci[17] Bitmap Pointer
6081		✗	Z_scripterrlog("bitmap quad pointer: %d\n", sdci[17]);
6082		✗	if ( sdci[17] <= 0 )
6083			{
6084		✗	Z_scripterrlog("bitmap->Quad() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6085		✗	return;
6086			}
6087		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
6088
6089		✗	if ( !refbmp ) return;
6090
6091		✗	int32_t x1 = sdci[2]/10000;
6092		✗	int32_t y1 = sdci[3]/10000;
6093		✗	int32_t x2 = sdci[4]/10000;
6094		✗	int32_t y2 = sdci[5]/10000;
6095		✗	int32_t x3 = sdci[6]/10000;
6096		✗	int32_t y3 = sdci[7]/10000;
6097		✗	int32_t x4 = sdci[8]/10000;
6098		✗	int32_t y4 = sdci[9]/10000;
6099		✗	int32_t w = sdci[10]/10000;
6100		✗	int32_t h = sdci[11]/10000;
6101		✗	int32_t color = sdci[12]/10000;
6102		✗	int32_t flip=(sdci[13]/10000)&3;
6103		✗	int32_t tile = sdci[14]/10000;
6104		✗	int32_t polytype = sdci[15]/10000;
6105		✗	int32_t quad_render_source = sdci[16]-10;
6106			//Z_scripterrlog("bitmap->Quad() render source is: %d\n", quad_render_source);
6107
6108		✗	bool tex_is_bitmap = ( sdci[16] != 0 );
6109
6110		✗	BITMAP *bmptexture=NULL;
6111		✗	BITMAP *tex=NULL;
6112		✗	polytype = vbound(polytype, 0, 14);
6113
6114			int32_t col[4];
6115		✗	col[0]=col[1]=col[2]=col[3]=color;
6116		✗	bool mustDestroyBmp = false;
6117
6118		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6119
6120		✗	if ( tex_is_bitmap )
6121			{
6122		✗	bmptexture = FFCore.GetScriptBitmap(quad_render_source);
6123		✗	if ( !bmptexture )
6124			{
6125		✗	Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Triangle3()");
6126		✗	tex_is_bitmap = 0;
6127			}
6128			}
6129
6130		✗	if ( tex_is_bitmap )
6131			{
6132
6133		✗	if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
6134		✗	if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
6135		✗	if ( !isPowerOfTwo(w) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", w);
6136		✗	if ( !isPowerOfTwo(h) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Quad is not a POWER OF TWO.\nTextels may render improperly!\n", h);
6137
6138		✗	V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6139		✗	V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(h), col[1] };
6140		✗	V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(w), static_cast<float>(h), col[2] };
6141		✗	V3D_f V4 = { static_cast<float>(x4+xoffset), static_cast<float>(y4+yoffset), 0, static_cast<float>(w), 0, col[3] };
6142
6143		✗	quad3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3, &V4);
6144			}
6145			else
6146			{
6147		✗	tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
6148		✗	if(!tex)
6149			{
6150			//Z_scripterrlog("Bitmap->Quad() found an invalid texture bitmap.\n");
6151		✗	mustDestroyBmp = true;
6152		✗	tex = create_bitmap_ex(8, w*16, h*16);
6153		✗	clear_bitmap(tex);
6154			}
6155
6156		✗	if(tile > 0) // TILE
6157			{
6158		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
6159			}
6160
6161		✗	if ( tile < 0 ) // COMBO
6162			{
6163		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
6164		✗	const int32_t tiletodraw = combo_tile(c, x1, y1);
6165		✗	flip = flip ^ c.flip;
6166
6167		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
6168			}
6169		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
6170			{
6171		✗	Z_message("Quad() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
6172		✗	return; //non power of two error
6173			}
6174			//Z_scripterrlog("bitmap->Quad() is trying to blit from a bitmap texture.\n");
6175		✗	V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6176		✗	V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(h), col[1] };
6177		✗	V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(w), static_cast<float>(h), col[2] };
6178		✗	V3D_f V4 = { static_cast<float>(x4+xoffset), static_cast<float>(y4+yoffset), 0, static_cast<float>(w), 0, col[3] };
6179
6180		✗	quad3d_f(refbmp, polytype, tex, &V1, &V2, &V3, &V4);
6181
6182			}
6183
6184
6185
6186
6187			//todo: finish palette shading
6188			/*
6189			POLYTYPE_FLAT
6190			POLYTYPE_GCOL
6191			POLYTYPE_GRGB
6192			POLYTYPE_ATEX
6193			POLYTYPE_PTEX
6194			POLYTYPE_ATEX_MASK
6195			POLYTYPE_PTEX_MASK
6196			POLYTYPE_ATEX_LIT
6197			POLYTYPE_PTEX_LIT
6198			POLYTYPE_ATEX_MASK_LIT
6199			POLYTYPE_PTEX_MASK_LIT
6200			POLYTYPE_ATEX_TRANS
6201			POLYTYPE_PTEX_TRANS
6202			POLYTYPE_ATEX_MASK_TRANS
6203			POLYTYPE_PTEX_MASK_TRANS
6204			*/
6205
6206		✗	if(mustDestroyBmp)
6207		✗	destroy_bitmap(tex);
6208
6209			}
6210
6211
6212		✗	void bmp_do_getpixelr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6213			{
6214			//sdci[1]=layer
6215			//sdci[2]=x1
6216			//sdci[3]=y1
6217
6218			//sdci[17] Bitmap Pointer
6219		✗	if ( sdci[17] <= 0 )
6220			{
6221		✗	Z_scripterrlog("bitmap->GetPixel() wanted to read from an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6222		✗	return;
6223			}
6224		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
6225		✗	if ( refbmp == NULL ) return;
6226
6227
6228		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6229
6230		✗	int32_t x1 = sdci[2]/10000;
6231		✗	int32_t y1 = (sdci[3]/10000)+yoffset;
6232		✗	int32_t col = getpixel(scb.script_created_bitmaps[(sdci[17]-10)].u_bmp, x1, y1);
6233		✗	Z_scripterrlog("bitmap->GetPixel col is %d\n",col);
6234		✗	Z_scripterrlog("bitmap->GetPixel bitmap ptr is is %d\n",(sdci[17]-10));
6235		✗	FFCore.set_sarg1(col);
6236			}
6237
6238
6239
6240
6241		✗	void bmp_do_drawtriangler(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6242			{
6243			//sdci[1]=layer
6244			//sdci[2]=x1
6245			//sdci[3]=y1
6246			//sdci[4]=x2
6247			//sdci[5]=y2
6248			//sdci[6]=x3
6249			//sdci[7]=y3
6250			//sdci[8]=width
6251			//sdci[9]=height
6252			//sdci[10]=cset
6253			//sdci[11]=flip
6254			//sdci[12]=tile/combo
6255			//sdci[13]=polytype
6256			//sdci[17] Bitmap Pointer
6257		✗	if ( sdci[17] <= 0 )
6258			{
6259		✗	Z_scripterrlog("bitmap->Triangle() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
6260		✗	return;
6261			}
6262		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
6263		✗	if ( refbmp == NULL ) return;
6264
6265
6266		✗	int32_t render_source = sdci[14]-10;
6267			//Z_scripterrlog("bitmap->Triangle() render source is: %d\n", render_source);
6268
6269		✗	bool tex_is_bitmap = ( sdci[14] != 0 );
6270
6271		✗	BITMAP *bmptexture=NULL;
6272		✗	if ( tex_is_bitmap )
6273			{
6274		✗	bmptexture = FFCore.GetScriptBitmap(render_source);
6275		✗	if ( !bmptexture )
6276			{
6277		✗	Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Triangle3()");
6278		✗	tex_is_bitmap = 0;
6279			}
6280			}
6281
6282		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6283
6284		✗	int32_t x1 = sdci[2]/10000;
6285		✗	int32_t y1 = sdci[3]/10000;
6286		✗	int32_t x2 = sdci[4]/10000;
6287		✗	int32_t y2 = sdci[5]/10000;
6288		✗	int32_t x3 = sdci[6]/10000;
6289		✗	int32_t y3 = sdci[7]/10000;
6290		✗	int32_t w = sdci[8]/10000;
6291		✗	int32_t h = sdci[9]/10000;
6292		✗	int32_t color = sdci[10]/10000;
6293		✗	int32_t flip=(sdci[11]/10000)&3;
6294		✗	int32_t tile = sdci[12]/10000;
6295		✗	int32_t polytype = sdci[13]/10000;
6296
6297		✗	polytype = vbound(polytype, 0, 14);
6298		✗	int32_t utex_w = w;
6299		✗	int32_t utex_h = h;
6300
6301
6302		✗	int32_t tex_width = w*16;
6303		✗	int32_t tex_height = h*16;
6304
6305		✗	bool mustDestroyBmp = false;
6306		✗	BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
6307
6308		✗	if(!tex)
6309			{
6310		✗	mustDestroyBmp = true;
6311		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
6312		✗	clear_bitmap(tex);
6313			}
6314
6315			int32_t col[3];
6316			/*
6317			if( color < 0 )
6318			{
6319			col[0]=draw_container.color_buffer[0];
6320			col[1]=draw_container.color_buffer[1];
6321			col[2]=draw_container.color_buffer[2];
6322			}
6323			else */
6324			{
6325		✗	col[0]=col[1]=col[2]=color;
6326			}
6327
6328		✗	if(tile > 0) // TILE
6329			{
6330		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, color, flip);
6331			}
6332			else // COMBO
6333			{
6334		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
6335		✗	const int32_t tiletodraw = combo_tile(c, x1, y1);
6336		✗	flip = flip ^ c.flip;
6337
6338		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, color, flip);
6339			}
6340		✗	if ( !tex_is_bitmap )
6341			{
6342		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
6343			{
6344		✗	Z_message("bitmap->Triangle() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
6345		✗	return; //non power of two error
6346			}
6347		✗	V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6348		✗	V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(tex_height), col[1] };
6349		✗	V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(tex_width), static_cast<float>(tex_height), col[2] };
6350
6351
6352		✗	triangle3d_f(refbmp, polytype, tex, &V1, &V2, &V3);
6353
6354			}
6355
6356			else
6357			{
6358		✗	if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", render_source);
6359		✗	if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", render_source);
6360		✗	if ( !isPowerOfTwo(utex_h) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", utex_w);
6361		✗	if ( !isPowerOfTwo(utex_w) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Triangle is not a POWER OF TWO.\nTextels may render improperly!\n", utex_h);
6362
6363		✗	V3D_f V1 = { static_cast<float>(x1+xoffset), static_cast<float>(y1+yoffset), 0, 0, 0, col[0] };
6364		✗	V3D_f V2 = { static_cast<float>(x2+xoffset), static_cast<float>(y2+yoffset), 0, 0, static_cast<float>(utex_h), col[1] };
6365		✗	V3D_f V3 = { static_cast<float>(x3+xoffset), static_cast<float>(y3+yoffset), 0, static_cast<float>(utex_w), static_cast<float>(utex_h), col[2] };
6366
6367
6368		✗	triangle3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3);
6369
6370			}
6371
6372		✗	if(mustDestroyBmp)
6373		✗	destroy_bitmap(tex);
6374			}
6375
6376
6377		✗	void bmp_do_mode7r(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6378			{
6379			/*
6380			int32_t layer, int32_t rt, int32_t srcX, int32_t srcY, int32_t srcW, int32_t srcH, int32_t destW, int32_t destH, int32_t angle, int32_t cx, int32_t cy, int32_t space_z, int32_t horizon,
6381			int32_t scale_x, int32_t scale_y){
6382
6383			//sdci[1]=layer
6384			//sdci[2]=bitmap target
6385			//
6386			// -2 is the current Render Target
6387			// -1, this is the screen (framebuf).
6388			// 0: Render target 0
6389			// 1: Render target 1
6390			// 2: Render target 2
6391			// 3: Render target 3
6392			// 4: Render target 4
6393			// 5: Render target 5
6394			// 6: Render target 6
6395			// Otherwise: The pointer to a bitmap.
6396
6397			//sdci[3]=sourcex
6398			//sdci[4]=sourcey
6399			//sdci[5]=sourcew
6400			//sdci[6]=sourceh
6401
6402			//sdci[7]=destw
6403			//sdci[8]=desth
6404			//sdci[9]=angle
6405			//scdi[10] = pivot cx
6406			//sdci[11] = pivot cy
6407			//sdci[12] = space Z
6408			//sdci[13] = horizon
6409			//scdi[14] = scale X
6410			//scdi[15] = scale Y
6411			//sdci[16] = masked?
6412			//sdci[17] Bitmap Pointer
6413
6414
6415
6416			// ZScript-side constant values:
6417			const int32_t BITDX_NORMAL = 0;
6418			const int32_t BITDX_TRANS = 1; //Translucent
6419			const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
6420			const int32_t BITDX_HFLIP = 4; //Horizontal Flip
6421			const int32_t BITDX_VFLIP = 8; //Vertical Flip.
6422			//Note: Some modes cannot be combined. if a combination is not supported, an error
6423			// detailing this will be shown in allegro.log.
6424
6425			//scdi[15] = litcolour
6426			//The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
6427			//not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
6428
6429			//sdci[16]=mask
6430
6431			*/
6432
6433
6434		✗	int32_t bitmapIndex = sdci[2];
6435		✗	int32_t usr_bitmap_index = sdci[2]-10;
6436		✗	byte using_user_bitmap = 0;
6437			//Z_scripterrlog("bitmap index is: %d\n",bitmapIndex);
6438			//Z_scripterrlog("Blit() bitmapIndex is: %d\n", bitmapIndex);
6439			#if LOG_BMPBLIT_LEVEL > 0
6440			Z_scripterrlog("Blit() found a dest bitmap ID of: %d\n",bitmapIndex);
6441			#endif
6442		✗	if ( bitmapIndex >= 10000 )
6443			{
6444		✗	bitmapIndex = bitmapIndex / 10000; //reduce if ZScript sent a raw value, such as bitmap = <int32_t> 8;
6445			}
6446		✗	else if ( usr_bitmap_index > 0 && usr_bitmap_index < 10000 )
6447			{
6448		✗	bitmapIndex = usr_bitmap_index;
6449		✗	using_user_bitmap = 1;
6450		✗	Z_scripterrlog("Mode7 is using a user bitmap target, pointer: %d\n", usr_bitmap_index);
6451		✗	yoffset = 0;
6452			}
6453
6454			//int32_t sx = sdci[3]/10000;
6455			//int32_t sy = sdci[4]/10000;
6456			//int32_t sw = sdci[5]/10000;
6457			//Z_scripterrlog("sh is: %d\n",sdci[5]/10000);
6458			//int32_t sh = sdci[6]/10000;
6459			//Z_scripterrlog("sh is: %d\n",sdci[6]/10000);
6460			//int32_t dx = sdci[7]/10000;
6461			//int32_t dy = sdci[8]/10000;
6462			//int32_t dw = sdci[9]/10000;
6463			//int32_t dh = sdci[10]/10000;
6464			//float rot = sdci[11]/10000;
6465			//int32_t cx = sdci[12]/10000;
6466			//int32_t cy = sdci[13]/10000;
6467			//int32_t mode = sdci[14]/10000;
6468			//int32_t litcolour = sdci[15]/10000;
6469
6470			//rendering mode 7 args
6471		✗	double srcX = sdci[3]/10000.0;
6472		✗	double srcY = sdci[4]/10000.0;
6473		✗	double destX = sdci[5]/10000.0;
6474		✗	double destY = sdci[6]/10000.0;
6475
6476
6477			// int32_t srcW = sdci[5]/10000;
6478			// int32_t srcH = sdci[6]/10000;
6479		✗	double destW = sdci[7]/10000.0;
6480		✗	double destH = sdci[8]/10000.0;
6481			// int32_t angle = sdci[9]/10000;
6482			// int32_t cx = sdci[10]/10000;
6483			// int32_t cy = sdci[11]/10000;
6484		✗	double space_z = sdci[9]/10000.0;
6485		✗	double horizon = sdci[10]/10000.0;
6486		✗	double scale_x = sdci[11]/10000.0;
6487		✗	double scale_y = sdci[12]/10000.0;
6488		✗	byte masked = ( sdci[13] ) ? 1 : 0;
6489
6490
6491		✗	int32_t ref = 0;
6492
6493			//dx = 0 + xoffset;
6494			//dy = 0 + yoffset;
6495
6496		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6497			//Do we need to also check the render target and do the same thing if the
6498			//dest == -2 and the render target is not RT_SCREEN?
6499
6500		✗	ref = sdci[17];
6501			//Z_scripterrlog("bitmap->blit() ref id this frame is: %d\n", ref);
6502		✗	ref -=10;
6503			//Z_scripterrlog("bitmap->blit() modified ref id this frame is: %d\n", ref);
6504
6505
6506		✗	if ( ref <= 0 )
6507			{
6508		✗	Z_scripterrlog("bitmap->blit() wanted to use to an invalid source bitmap id: %d. Aborting.\n", ref);
6509		✗	return;
6510			}
6511		✗	BITMAP *sourceBitmap = FFCore.GetScriptBitmap(ref); //This can be the screen, as -1.
6512			#if LOG_BMPBLIT_LEVEL > 0
6513			Z_scripterrlog("bitmap->Blit() is trying to blit to ref: %d\n",sdci[17]);
6514			#endif
6515		✗	if(!sourceBitmap)
6516			{
6517		✗	Z_message("Warning: blit(%d) source bitmap contains invalid data or is not initialized.\n", ref);
6518		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6519		✗	return;
6520			}
6521
6522		✗	BITMAP *destBMP=NULL;
6523			//zprint2("mode 7 bitmap index is: %d\n",bitmapIndex);
6524		✗	switch(bitmapIndex)
6525			{
6526			case -2:
6527			{
6528		✗	int32_t curr_rt = zscriptDrawingRenderTarget->GetCurrentRenderTarget();
6529			//zprint2("current RT is: %d\n", curr_rt);
6530		✗	if ( curr_rt >= 0 && curr_rt < 7 )
6531		✗	destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); //Drawing to the current RenderTarget.
6532		✗	else destBMP = bmp; //screen
6533		✗	break;
6534			}
6535			case -1:
6536		✗	destBMP = bmp; //this is framebuf, by default
6537		✗	break;
6538			//zscriptDrawingRenderTarget->SetCurrentRenderTarget(bitmapIndex);
6539			//destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6540			//destBMP = framebuf; //Drawing to the screen.
6541			//break;
6542
6543			//1 through 6 are the old system bitmaps (Render Targets)
6544			case 0:
6545			case 1:
6546			case 2:
6547			case 3:
6548			case 4:
6549			case 5:
6550			case 6:
6551			{
6552			//This gets a render target.
6553			//destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); break;
6554
6555		✗	destBMP = zscriptDrawingRenderTarget->GetTargetBitmap(bitmapIndex);
6556			//sdci[18] = bitmapIndex;
6557		✗	break;
6558			}
6559			//Otherwise, we are using a user-created bitmap, so, get that pointer insted.
6560			default:
6561			{
6562		✗	destBMP = scb.script_created_bitmaps[usr_bitmap_index].u_bmp;
6563			//sdci[18] = usr_bitmap_index;
6564		✗	if ( !scb.script_created_bitmaps[usr_bitmap_index].u_bmp )
6565			{
6566		✗	Z_scripterrlog("Target for bitmap->Blit is uninitialised. Aborting.\n");
6567		✗	break;
6568			}
6569			}
6570			//FFCore.get_user_bitmap(bitmapIndex); break;
6571			}
6572
6573
6574
6575			#if LOG_BMPBLIT_LEVEL > 0
6576			Z_scripterrlog("bitmap->Blit() is trying to blit to dest bitmap ID: %d\n",bitmapIndex);
6577			#endif
6578
6579
6580		✗	if (!destBMP)
6581			{
6582		✗	Z_message("Warning: blit(%d) destination bitmap contains invalid data or is not initialized.\n", bitmapIndex);
6583		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6584		✗	return;
6585			}
6586
6587			//bugfix
6588			//sx = vbound(sx, 0, sourceBitmap->w);
6589			/* //These vars are named wrongly for this function -V
6590			#if LOG_BMPBLIT_LEVEL > 0
6591			Z_scripterrlog("Blit %s is: %d\n", "sx", sx);
6592			Z_scripterrlog("Blit %s is: %d\n", "source->w", sourceBitmap->w);
6593			#endif
6594			//sy = vbound(sy, 0, sourceBitmap->h);
6595			#if LOG_BMPBLIT_LEVEL > 0
6596			Z_scripterrlog("Blit %s is: %d\n", "sy", sy);
6597			Z_scripterrlog("Blit %s is: %d\n", "source->h", sourceBitmap->h);
6598			#endif
6599			//sw = vbound(sw, 0, sourceBitmap->w - sx); //keep the w/h within range as well
6600			#if LOG_BMPBLIT_LEVEL > 0
6601			Z_scripterrlog("Blit %s is: %d\n", "sw", sw);
6602			#endif
6603			//sh = vbound(sh, 0, sourceBitmap->h - sy);
6604			#if LOG_BMPBLIT_LEVEL > 0
6605			Z_scripterrlog("Blit %s is: %d\n", "sh", sh);
6606
6607			Z_scripterrlog("Blit %s is: %d\n", "dh", dh);
6608			Z_scripterrlog("Blit %s is: %d\n", "dw", dw);
6609			#endif
6610			//bool stretched = (sw != dw || sh != dh);
6611			//bool stretched = (sourceBitmap->w != destBMP->w || sourceBitmap->h != destBMP->h);
6612			#if LOG_BMPBLIT_LEVEL > 0
6613			Z_scripterrlog("Blit %s is: %s\n", "stretched", stretched ? "true" : "false");
6614			#endif
6615			*/
6616			//BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6617
6618
6619
6620
6621
6622		✗	BITMAP* subBmp = 0;
6623
6624			/* IDR what this was. -Z ( 17th April, 2019 )
6625			if ( bitmapIndex == -1 ) {
6626			blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
6627			}
6628			*/
6629
6630			//if(rot != 0 || mode != 0)
6631			//{
6632			// subBmp = create_bitmap_ex(8,sourceBitmap->w, sourceBitmap->h);//script_drawing_commands.AquireSubBitmap(dw, dh);
6633			// clear_bitmap(subBmp);
6634
6635			// if(!subBmp)
6636			// {
6637			// Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
6638			// return;
6639			// }
6640			//}
6641
6642
6643			//dx = dx + xoffset; //don't do this here!
6644			//dy = dy + yoffset; //Nor this. It auto-offsets the bitmap by +56. Hmm. The fix that gleeok made isn't being applied to these functions. -Z ( 17th April, 2019 )
6645			//All of these are a factor of 10000 as fix.
6646		✗	int32_t screen_x = 0; int32_t screen_y = 0;
6647
6648		✗	double distance = 0; double horizontal_scale = 0;
6649
6650		✗	int32_t screen_y_horizon = 0;
6651
6652		✗	double line_dx = 0; double line_dy = 0;
6653
6654		✗	int32_t space_x = 0; int32_t space_y = 0;
6655
6656		✗	for(screen_y = 0; screen_y < destH; screen_y++) //fix, offset by .0000
6657			{
6658			//Calculate the distance of each line from the camera point
6659		✗	screen_y_horizon = screen_y + horizon;
6660
6661		✗	distance = ((space_z * scale_y) / ((screen_y_horizon != 0) ? screen_y_horizon : 1));
6662
6663			//Get the scale of each line based on the distance
6664
6665		✗	horizontal_scale = (distance / (( scale_x != 0 ) ? scale_x : 1));
6666
6667			//There was some math here before I stripped out the rotation step
6668		✗	line_dx = horizontal_scale;
6669		✗	line_dy = 0;
6670
6671			//space_x,space_y - where to grab each scanline from on the space bitmap
6672		✗	space_x = srcX - destW/2.0 * line_dx;
6673		✗	space_y = srcY - distance + destH/2.0 * line_dy;
6674
6675			//Keep blits within the bounds of both bitmaps to avoid crashes
6676		✗	int32_t y1 = srcY+space_y;
6677		✗	int32_t y2 = destY+screen_y;
6678		✗	if(y1 >=0 && y1 <= (sourceBitmap->h-1) && y2 >=0 && y2 <= (destBMP->h-1) )
6679			{
6680		✗	if ( masked ) masked_stretch_blit(sourceBitmap, destBMP, (int32_t)(srcX+space_x), (int32_t)(srcY+space_y),
6681		✗	(int32_t)(line_dx*destW), 1, (int32_t)(screen_x), (int32_t)(screen_y)+yoffset, (int32_t)(destW), 1);
6682		✗	else stretch_blit(sourceBitmap, destBMP, (int32_t)(srcX+space_x), (int32_t)(srcY+space_y),
6683		✗	(int32_t)(line_dx*destW), 1, (int32_t)(screen_x), (int32_t)(screen_y)+yoffset, (int32_t)(destW), 1);
6684			}
6685			}
6686
6687
6688			//cleanup
6689		✗	if(subBmp)
6690			{
6691			//script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
6692		✗	destroy_bitmap(subBmp);
6693			}
6694			}
6695
6696
6697			//Draw]()
6698		✗	void bmp_do_drawbitmapexr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
6699			{
6700			/*
6701			//sdci[1]=layer
6702			//sdci[2]=bitmap target
6703			//
6704			// -2 is the current Render Target
6705			// -1, this is the screen (framebuf).
6706			// 0: Render target 0
6707			// 1: Render target 1
6708			// 2: Render target 2
6709			// 3: Render target 3
6710			// 4: Render target 4
6711			// 5: Render target 5
6712			// 6: Render target 6
6713			// Otherwise: The pointer to a bitmap.
6714
6715			//sdci[3]=sourcex
6716			//sdci[4]=sourcey
6717			//sdci[5]=sourcew
6718			//sdci[6]=sourceh
6719			//sdci[7]=destx
6720			//sdci[8]=desty
6721			//sdci[9]=destw
6722			//sdci[10]=desth
6723			//sdci[11]=rotation/angle
6724			//scdi[12] = pivot cx
6725			//sdci[13] = pivot cy
6726			//scdi[14] = effect flags
6727			//sdci[17] Bitmap Pointer
6728
6729			// ZScript-side constant values:
6730			const int32_t BITDX_NORMAL = 0;
6731			const int32_t BITDX_TRANS = 1; //Translucent
6732			const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
6733			const int32_t BITDX_HFLIP = 4; //Horizontal Flip
6734			const int32_t BITDX_VFLIP = 8; //Vertical Flip.
6735			//Note: Some modes cannot be combined. if a combination is not supported, an error
6736			// detailing this will be shown in allegro.log.
6737
6738			//scdi[15] = litcolour
6739			//The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
6740			//not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
6741
6742			//sdci[16]=mask
6743
6744			*/
6745
6746		✗	int32_t bitmapIndex = sdci[2]/10000;
6747		✗	int32_t usr_bitmap_index = sdci[2]-10;
6748		✗	byte using_user_bitmap = 0;
6749			//Z_scripterrlog("bitmap index is: %d\n",bitmapIndex);
6750			//Z_scripterrlog("Blit() bitmapIndex is: %d\n", bitmapIndex);
6751			#if LOG_BMPBLIT_LEVEL > 0
6752			Z_scripterrlog("Blit() found a dest bitmap ID of: %d\n",bitmapIndex);
6753			#endif
6754		✗	if ( bitmapIndex > 10000 )
6755			{
6756		✗	bitmapIndex = bitmapIndex / 10000; //reduce if ZScript sent a raw value, such as bitmap = <int32_t> 8;
6757			}
6758		✗	if ( usr_bitmap_index > 0 && usr_bitmap_index < 10000 )
6759			{
6760		✗	bitmapIndex = usr_bitmap_index;
6761		✗	using_user_bitmap = 1;
6762		✗	yoffset = 0;
6763			}
6764
6765		✗	int32_t sx = sdci[3]/10000;
6766		✗	int32_t sy = sdci[4]/10000;
6767		✗	int32_t sw = sdci[5]/10000;
6768			//Z_scripterrlog("sh is: %d\n",sdci[5]/10000);
6769		✗	int32_t sh = sdci[6]/10000;
6770			//Z_scripterrlog("sh is: %d\n",sdci[6]/10000);
6771		✗	int32_t dx = sdci[7]/10000;
6772		✗	int32_t dy = sdci[8]/10000;
6773		✗	int32_t dw = sdci[9]/10000;
6774		✗	int32_t dh = sdci[10]/10000;
6775		✗	float rot = sdci[11]/10000;
6776		✗	int32_t cx = sdci[12]/10000;
6777		✗	int32_t cy = sdci[13]/10000;
6778		✗	int32_t mode = sdci[14]/10000;
6779		✗	int32_t litcolour = sdci[15]/10000;
6780		✗	bool masked = (sdci[16] != 0);
6781
6782		✗	int32_t ref = 0;
6783
6784		✗	dx = dx + xoffset;
6785		✗	dy = dy + yoffset;
6786
6787		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
6788			//Do we need to also check the render target and do the same thing if the
6789			//dest == -2 and the render target is not RT_SCREEN?
6790
6791		✗	ref = sdci[17];
6792			//Z_scripterrlog("bitmap->blit() ref id this frame is: %d\n", ref);
6793		✗	ref -=10;
6794			//Z_scripterrlog("bitmap->blit() modified ref id this frame is: %d\n", ref);
6795
6796
6797		✗	if ( ref <= 0 )
6798			{
6799		✗	Z_scripterrlog("bitmap->blit() wanted to use to an invalid source bitmap id: %d. Aborting.\n", ref);
6800		✗	return;
6801			}
6802		✗	BITMAP *sourceBitmap = FFCore.GetScriptBitmap(ref); //This can be the screen, as -1.
6803			#if LOG_BMPBLIT_LEVEL > 0
6804			Z_scripterrlog("bitmap->Blit() is trying to blit to ref: %d\n",sdci[17]);
6805			#endif
6806		✗	if(!sourceBitmap)
6807			{
6808
6809		✗	Z_message("Warning: blit(%d) source bitmap contains invalid data or is not initialized.\n", ref);
6810		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6811		✗	return;
6812			}
6813
6814		✗	BITMAP *destBMP=NULL;
6815			//zprint2("blit () bitmap index is: %d\n",bitmapIndex);
6816		✗	switch(bitmapIndex)
6817			{
6818			case -2:
6819			{
6820		✗	int32_t curr_rt = zscriptDrawingRenderTarget->GetCurrentRenderTarget();
6821			//zprint2("current RT is: %d\n", curr_rt);
6822		✗	if ( curr_rt >= 0 && curr_rt < 7 )
6823		✗	destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); //Drawing to the current RenderTarget.
6824		✗	else destBMP = bmp; //screen
6825		✗	break;
6826			}
6827			case -1:
6828		✗	destBMP = bmp; //this is framebuf, by default
6829		✗	break;
6830			//zscriptDrawingRenderTarget->SetCurrentRenderTarget(bitmapIndex);
6831			//destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6832			//destBMP = framebuf; //Drawing to the screen.
6833			//break;
6834
6835			//1 through 6 are the old system bitmaps (Render Targets)
6836			case 0:
6837			case 1:
6838			case 2:
6839			case 3:
6840			case 4:
6841			case 5:
6842			case 6:
6843			{
6844			//This gets a render target.
6845		✗	destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); break;
6846
6847			//destBMP = zscriptDrawingRenderTarget->GetTargetBitmap(bitmapIndex);
6848			//sdci[18] = bitmapIndex;
6849			break;
6850			}
6851			//Otherwise, we are using a user-created bitmap, so, get that pointer insted.
6852			default:
6853			{
6854		✗	destBMP = scb.script_created_bitmaps[usr_bitmap_index].u_bmp;
6855			//sdci[18] = usr_bitmap_index;
6856		✗	if ( !scb.script_created_bitmaps[usr_bitmap_index].u_bmp )
6857			{
6858		✗	Z_scripterrlog("Target for bitmap->Blit is uninitialised. Aborting.\n");
6859		✗	break;
6860			}
6861			}
6862			//FFCore.get_user_bitmap(bitmapIndex); break;
6863			}
6864
6865
6866
6867			#if LOG_BMPBLIT_LEVEL > 0
6868			Z_scripterrlog("bitmap->Blit() is trying to blit to dest bitmap ID: %d\n",bitmapIndex);
6869			#endif
6870
6871
6872		✗	if (!destBMP)
6873			{
6874
6875		✗	Z_message("Warning: blit(%d) destination bitmap contains invalid data or is not initialized.\n", bitmapIndex);
6876		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
6877		✗	return;
6878			}
6879
6880			//bugfix
6881			//sx = vbound(sx, 0, sourceBitmap->w);
6882			#if LOG_BMPBLIT_LEVEL > 0
6883			Z_scripterrlog("Blit %s is: %d\n", "sx", sx);
6884			Z_scripterrlog("Blit %s is: %d\n", "source->w", sourceBitmap->w);
6885			#endif
6886			//sy = vbound(sy, 0, sourceBitmap->h);
6887			#if LOG_BMPBLIT_LEVEL > 0
6888			Z_scripterrlog("Blit %s is: %d\n", "sy", sy);
6889			Z_scripterrlog("Blit %s is: %d\n", "source->h", sourceBitmap->h);
6890			#endif
6891			//sw = vbound(sw, 0, sourceBitmap->w - sx); //keep the w/h within range as well
6892			#if LOG_BMPBLIT_LEVEL > 0
6893			Z_scripterrlog("Blit %s is: %d\n", "sw", sw);
6894			#endif
6895			//sh = vbound(sh, 0, sourceBitmap->h - sy);
6896			#if LOG_BMPBLIT_LEVEL > 0
6897			Z_scripterrlog("Blit %s is: %d\n", "sh", sh);
6898
6899			Z_scripterrlog("Blit %s is: %d\n", "dh", dh);
6900			Z_scripterrlog("Blit %s is: %d\n", "dw", dw);
6901			#endif
6902		✗	bool stretched = (sw != dw || sh != dh);
6903			//bool stretched = (sourceBitmap->w != destBMP->w || sourceBitmap->h != destBMP->h);
6904			#if LOG_BMPBLIT_LEVEL > 0
6905			Z_scripterrlog("Blit %s is: %s\n", "stretched", stretched ? "true" : "false");
6906			#endif
6907			//BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
6908
6909
6910
6911
6912
6913		✗	BITMAP* subBmp = 0;
6914
6915			/* IDR what this was. -Z ( 17th April, 2019 )
6916			if ( bitmapIndex == -1 ) {
6917			blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
6918			}
6919			*/
6920
6921		✗	if(rot != 0 || mode != 0)
6922			{
6923		✗	subBmp = create_bitmap_ex(8,sourceBitmap->w, sourceBitmap->h);//script_drawing_commands.AquireSubBitmap(dw, dh);
6924		✗	clear_bitmap(subBmp);
6925
6926		✗	if(!subBmp)
6927			{
6928
6929		✗	Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
6930		✗	return;
6931			}
6932			}
6933		✗	BITMAP* sbmp = sourceBitmap;
6934		✗	if (sx + sw > sbmp->w || sy + sh > sbmp->h)
6935			{
6936		✗	sbmp = create_bitmap_ex(8, sw, sh);
6937		✗	clear_bitmap(sbmp);
6938		✗	blit(sourceBitmap, sbmp, sx, sy, 0, 0, std::min(sourceBitmap->w-sx, sw), std::min(sourceBitmap->h-sy, sh));
6939		✗	sx = 0;
6940		✗	sy = 0;
6941			}
6942			//dx = dx + xoffset; //don't do this here!
6943			//dy = dy + yoffset; //Nor this. It auto-offsets the bitmap by +56. Hmm. The fix that gleeok made isn't being applied to these functions. -Z ( 17th April, 2019 )
6944
6945		✗	if(stretched)
6946			{
6947		✗	if(masked)
6948			{ //stretched and masked
6949		✗	if ( rot == 0 )
6950			{ //if not rotated
6951		✗	switch(mode)
6952			{
6953			case 1:
6954			//transparent
6955		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6956		✗	draw_trans_sprite(destBMP, subBmp, dx, dy);
6957		✗	break;
6958
6959
6960			case 2:
6961			//pivot?
6962		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6963		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
6964			//Pivoting requires two more args
6965		✗	break;
6966
6967			case 3:
6968			//pivot + trans
6969		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6970		✗	pivot_sprite_trans(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
6971		✗	break;
6972
6973			case 4:
6974			//flip v
6975		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6976		✗	draw_sprite_v_flip(destBMP, subBmp, dx, dy);
6977		✗	break;
6978
6979			case 5:
6980			//trans + v flip
6981		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6982		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
6983		✗	break;
6984
6985			case 6:
6986			//pivot + v flip
6987		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6988		✗	pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
6989		✗	break;
6990
6991			case 8:
6992			//vlip h
6993		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
6994		✗	draw_sprite_h_flip(destBMP, subBmp, dx, dy);
6995		✗	break;
6996
6997			case 9:
6998			//trans + h flip
6999		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7000		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7001		✗	break;
7002
7003			case 10:
7004			//flip H and pivot
7005		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7006			//return error cannot pivot and h flip
7007		✗	break;
7008
7009			case 12:
7010			//vh flip
7011		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7012		✗	draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7013		✗	break;
7014
7015			case 13:
7016			//trans + vh flip
7017		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7018		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7019		✗	break;
7020
7021			case 14:
7022			//pivot and vh flip
7023		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7024			//return error cannot both pivot and vh flip
7025		✗	break;
7026
7027			case 16:
7028			//lit
7029		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7030		✗	draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7031		✗	break;
7032
7033			case 18:
7034			//pivot, lit
7035		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7036		✗	pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7037		✗	break;
7038
7039			case 20:
7040			//lit + v flip
7041		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7042		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7043		✗	break;
7044
7045			case 22:
7046			//Pivot, vflip, lit
7047		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7048		✗	pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7049		✗	break;
7050
7051			case 24:
7052			//lit + h flip
7053		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7054		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7055		✗	break;
7056
7057			case 26:
7058			//pivot + lit + hflip
7059		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7060			//return error cannot pivot, lit, and flip
7061		✗	break;
7062
7063			case 28:
7064			//lit + vh flip
7065		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7066		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7067		✗	break;
7068
7069			case 32: //gouraud
7070			//Probably not wort supporting.
7071			//masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7072			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7073		✗	break;
7074
7075			case 0:
7076			//no effect
7077		✗	masked_stretch_blit(sbmp, destBMP, sx, sy, sw, sh, dx, dy, dw, dh);
7078		✗	break;
7079
7080
7081			default:
7082
7083		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7084
7085
7086			}
7087			} //end if not rotated
7088
7089		✗	if ( rot != 0 ) //if rotated
7090			{
7091		✗	switch(mode)
7092			{
7093			case 1:
7094			//transparent
7095		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7096		✗	rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7097
7098		✗	break;
7099
7100			case 2:
7101			//pivot?
7102		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7103		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7104			//Pivoting requires two more args
7105		✗	break;
7106
7107			case 3:
7108			//pivot + trans
7109			//return an error, cannot both rotate and pivot
7110		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7111		✗	break;
7112
7113			case 4:
7114			//flip v
7115		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7116		✗	rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7117		✗	break;
7118
7119			case 5:
7120			//trans + v flip
7121		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7122		✗	rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7123		✗	break;
7124
7125			case 6:
7126			//pivot + v flip
7127		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7128			//return an error, cannot both rotate and pivot
7129		✗	break;
7130
7131			case 8:
7132			//flip h
7133		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7134			//return an error, cannot both rotate and flip H
7135		✗	break;
7136
7137			case 9:
7138			//trans + h flip
7139		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7140			//return an error, cannot rotate and flip a trans sprite
7141		✗	break;
7142
7143			case 10:
7144			//flip H and pivot
7145			//return error cannot pivot and h flip
7146		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7147		✗	break;
7148
7149			case 12:
7150			//vh flip
7151			//return an error, cannot rotate and VH flip a trans sprite
7152		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7153		✗	break;
7154
7155			case 13:
7156			//trans + vh flip
7157			//return an error, cannot rotate and VH flip a trans sprite
7158		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7159		✗	break;
7160
7161			case 14:
7162			//pivot and vh flip
7163		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7164			//return error cannot both pivot and vh flip
7165		✗	break;
7166
7167			case 16:
7168			//lit
7169		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7170		✗	rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7171		✗	break;
7172
7173			case 18:
7174			//pivot, lit
7175			//return an error, cannot both rotate and pivot
7176		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7177		✗	break;
7178
7179			case 20:
7180			//lit + vflip
7181		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7182		✗	rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7183		✗	break;
7184
7185			case 22:
7186			//Pivot, vflip, lit
7187			//return an error, cannot both rotate and pivot
7188		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7189		✗	break;
7190
7191			case 24:
7192			//lit + h flip
7193			//return an error, cannot both rotate and H flip
7194		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
7195		✗	break;
7196
7197			case 26:
7198			//pivot + lit + hflip
7199		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
7200			//return error cannot pivot, lit, and flip
7201		✗	break;
7202
7203			case 28:
7204			//lit + vh flip
7205			//return an error, cannot both rotate and VH flip
7206		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7207		✗	break;
7208
7209			case 32: //gouraud
7210			//Probably not wort supporting.
7211			//masked_stretch_blit(sourceBitmap, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7212			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7213		✗	break;
7214
7215			case 0:
7216			//no effect.
7217		✗	masked_stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7218		✗	rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7219		✗	break;
7220
7221			default:
7222
7223		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7224
7225			}
7226			}
7227			} //end if stretched and masked
7228
7229			else //stretched, not masked
7230			{
7231
7232
7233		✗	if ( rot == 0 ) //if not rotated
7234			{
7235		✗	switch(mode)
7236			{
7237			case 1:
7238			//transparent
7239		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7240		✗	draw_trans_sprite(destBMP, subBmp, dx, dy);
7241		✗	break;
7242
7243
7244			case 2:
7245			//pivot?
7246		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7247		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7248			//Pivoting requires two more args
7249		✗	break;
7250
7251			case 3:
7252			//pivot + trans
7253		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7254		✗	pivot_sprite_trans(destBMP, subBmp, dx,dy, cx, cy, degrees_to_fixed(rot));
7255		✗	break;
7256
7257			case 4:
7258			//flip v
7259		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7260		✗	draw_sprite_v_flip(destBMP, subBmp, dx, dy);
7261		✗	break;
7262
7263			case 5:
7264			//trans + v flip
7265		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7266		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
7267		✗	break;
7268
7269			case 6:
7270			//pivot + v flip
7271		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7272		✗	pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7273		✗	break;
7274
7275			case 8:
7276			//vlip h
7277		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7278		✗	draw_sprite_h_flip(destBMP, subBmp, dx, dy);
7279		✗	break;
7280
7281			case 9:
7282			//trans + h flip
7283		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7284		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7285		✗	break;
7286
7287			case 10:
7288			//flip H and pivot
7289		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7290			//return error cannot pivot and h flip
7291		✗	break;
7292
7293			case 12:
7294			//vh flip
7295		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7296		✗	draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7297		✗	break;
7298
7299			case 13:
7300			//trans + vh flip
7301		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7302		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7303		✗	break;
7304
7305			case 14:
7306			//pivot and vh flip
7307		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7308			//return error cannot both pivot and vh flip
7309		✗	break;
7310
7311			case 16:
7312			//lit
7313		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7314		✗	draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7315		✗	break;
7316
7317			case 18:
7318			//pivot, lit
7319		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7320		✗	pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7321		✗	break;
7322
7323			case 20:
7324			//lit + v flip
7325		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7326		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7327		✗	break;
7328
7329			case 22:
7330			//Pivot, vflip, lit
7331		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7332		✗	pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7333		✗	break;
7334
7335			case 24:
7336			//lit + h flip
7337		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7338		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7339		✗	break;
7340
7341			case 26:
7342			//pivot + lit + hflip
7343		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7344			//return error cannot pivot, lit, and flip
7345		✗	break;
7346
7347			case 28:
7348			//lit + vh flip
7349		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7350		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7351		✗	break;
7352
7353			case 32: //gouraud
7354			//Probably not wort supporting.
7355			//stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7356			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7357		✗	break;
7358
7359			case 0:
7360			//no effect
7361		✗	stretch_blit(sbmp, destBMP, sx, sy, sw, sh, dx, dy, dw, dh);
7362		✗	break;
7363
7364
7365			default:
7366
7367		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7368
7369
7370			}
7371			} //end if not rotated
7372
7373		✗	if ( rot != 0 ) //if rotated
7374			{
7375		✗	switch(mode)
7376			{
7377			case 1:
7378		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
7379		✗	rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7380
7381		✗	break;
7382
7383			case 2:
7384			//pivot?
7385		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7386		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7387			//Pivoting requires two more args
7388		✗	break;
7389
7390			case 3:
7391			//pivot + trans
7392			//return an error, cannot both rotate and pivot
7393		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7394		✗	break;
7395
7396			case 4:
7397			//flip v
7398		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7399		✗	rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7400		✗	break;
7401
7402			case 5:
7403			//trans + v flip
7404		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7405		✗	rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7406		✗	break;
7407
7408			case 6:
7409			//pivot + v flip
7410		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7411			//return an error, cannot both rotate and pivot
7412		✗	break;
7413
7414			case 8:
7415			//flip h
7416		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7417			//return an error, cannot both rotate and flip H
7418		✗	break;
7419
7420			case 9:
7421			//trans + h flip
7422		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7423			//return an error, cannot rotate and flip a trans sprite
7424		✗	break;
7425
7426			case 10:
7427			//flip H and pivot
7428			//return error cannot pivot and h flip
7429		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7430		✗	break;
7431
7432			case 12:
7433			//vh flip
7434			//return an error, cannot rotate and VH flip a trans sprite
7435		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7436		✗	break;
7437
7438			case 13:
7439			//trans + vh flip
7440			//return an error, cannot rotate and VH flip a trans sprite
7441		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7442		✗	break;
7443
7444			case 14:
7445			//pivot and vh flip
7446		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7447			//return error cannot both pivot and vh flip
7448		✗	break;
7449
7450			case 16:
7451			//lit
7452		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
7453		✗	rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7454		✗	break;
7455
7456			case 18:
7457			//pivot, lit
7458			//return an error, cannot both rotate and pivot
7459		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7460		✗	break;
7461
7462			case 20:
7463			//lit + vflip
7464		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
7465		✗	rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7466		✗	break;
7467
7468			case 22:
7469			//Pivot, vflip, lit
7470			//return an error, cannot both rotate and pivot
7471		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7472		✗	break;
7473
7474			case 24:
7475			//lit + h flip
7476			//return an error, cannot both rotate and H flip
7477		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
7478		✗	break;
7479
7480			case 26:
7481			//pivot + lit + hflip
7482		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
7483			//return error cannot pivot, lit, and flip
7484		✗	break;
7485
7486			case 28:
7487			//lit + vh flip
7488			//return an error, cannot both rotate and VH flip
7489		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7490		✗	break;
7491
7492			case 32: //gouraud
7493			//Probably not wort supporting.
7494			//stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7495			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7496		✗	break;
7497
7498			case 0:
7499			//no effect.
7500		✗	stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7501		✗	rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7502		✗	break;
7503
7504			default:
7505
7506		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7507
7508			}
7509			}
7510
7511			} //end if stretched, but not masked
7512			}
7513			else //not stretched
7514			{
7515
7516		✗	if(masked) //if masked, but not stretched
7517			{
7518
7519		✗	if ( rot == 0 ) //if not rotated
7520			{
7521		✗	switch(mode)
7522			{
7523			case 1:
7524			//transparent
7525		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7526		✗	draw_trans_sprite(destBMP, subBmp, dx, dy);
7527		✗	break;
7528
7529
7530			case 2:
7531			//pivot?
7532		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7533		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7534			//Pivoting requires two more args
7535		✗	break;
7536
7537			case 3:
7538			//pivot + trans
7539		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7540		✗	pivot_sprite_trans(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7541		✗	break;
7542
7543			case 4:
7544			//flip v
7545		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7546		✗	draw_sprite_v_flip(destBMP, subBmp, dx, dy);
7547		✗	break;
7548
7549			case 5:
7550			//trans + v flip
7551		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7552		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
7553		✗	break;
7554
7555			case 6:
7556			//pivot + v flip
7557		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7558		✗	pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7559		✗	break;
7560
7561			case 8:
7562			//vlip h
7563		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7564		✗	draw_sprite_h_flip(destBMP, subBmp, dx, dy);
7565		✗	break;
7566
7567			case 9:
7568			//trans + h flip
7569		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7570		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7571		✗	break;
7572
7573			case 10:
7574			//flip H and pivot
7575		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7576			//return error cannot pivot and h flip
7577		✗	break;
7578
7579			case 12:
7580			//vh flip
7581		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7582		✗	draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7583		✗	break;
7584
7585			case 13:
7586			//trans + vh flip
7587		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7588		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7589		✗	break;
7590
7591			case 14:
7592			//pivot and vh flip
7593		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7594			//return error cannot both pivot and vh flip
7595		✗	break;
7596
7597			case 16:
7598			//lit
7599		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7600		✗	draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7601		✗	break;
7602
7603			case 18:
7604			//pivot, lit
7605		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7606		✗	pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7607		✗	break;
7608
7609			case 20:
7610			//lit + v flip
7611		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7612		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7613		✗	break;
7614
7615			case 22:
7616			//Pivot, vflip, lit
7617		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7618		✗	pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7619		✗	break;
7620
7621			case 24:
7622			//lit + h flip
7623		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7624		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7625		✗	break;
7626
7627			case 26:
7628			//pivot + lit + hflip
7629		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7630			//return error cannot pivot, lit, and flip
7631		✗	break;
7632
7633			case 28:
7634			//lit + vh flip
7635		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7636		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7637		✗	break;
7638
7639			case 32: //gouraud
7640			//Probably not wort supporting.
7641			//stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7642			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7643		✗	break;
7644
7645			case 0:
7646			//no effect
7647		✗	masked_blit(sbmp, destBMP, sx, sy, dx, dy, dw, dh);
7648		✗	break;
7649
7650
7651			default:
7652
7653		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7654
7655
7656			}
7657			} //end if not rotated
7658
7659		✗	if ( rot != 0 ) //if rotated
7660			{
7661		✗	switch(mode)
7662			{
7663			case 1:
7664		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh); //transparent
7665		✗	rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7666
7667		✗	break;
7668
7669			case 2:
7670			//pivot?
7671		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7672		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7673			//Pivoting requires two more args
7674		✗	break;
7675
7676			case 3:
7677			//pivot + trans
7678			//return an error, cannot both rotate and pivot
7679		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7680		✗	break;
7681
7682			case 4:
7683			//flip v
7684		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7685		✗	rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7686		✗	break;
7687
7688			case 5:
7689		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh); //trans + v flip
7690		✗	rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7691		✗	break;
7692
7693			case 6:
7694			//pivot + v flip
7695		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7696			//return an error, cannot both rotate and pivot
7697		✗	break;
7698
7699			case 8:
7700			//flip h
7701		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7702			//return an error, cannot both rotate and flip H
7703		✗	break;
7704
7705			case 9:
7706			//trans + h flip
7707		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7708			//return an error, cannot rotate and flip a trans sprite
7709		✗	break;
7710
7711			case 10:
7712			//flip H and pivot
7713			//return error cannot pivot and h flip
7714		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7715		✗	break;
7716
7717			case 12:
7718			//vh flip
7719			//return an error, cannot rotate and VH flip a trans sprite
7720		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7721		✗	break;
7722
7723			case 13:
7724			//trans + vh flip
7725			//return an error, cannot rotate and VH flip a trans sprite
7726		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
7727		✗	break;
7728
7729			case 14:
7730			//pivot and vh flip
7731		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7732			//return error cannot both pivot and vh flip
7733		✗	break;
7734
7735			case 16:
7736			//lit
7737		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7738		✗	rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7739		✗	break;
7740
7741			case 18:
7742			//pivot, lit
7743			//return an error, cannot both rotate and pivot
7744		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7745		✗	break;
7746
7747			case 20:
7748			//lit + vflip
7749		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7750		✗	rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
7751		✗	break;
7752
7753			case 22:
7754			//Pivot, vflip, lit
7755			//return an error, cannot both rotate and pivot
7756		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
7757		✗	break;
7758
7759			case 24:
7760			//lit + h flip
7761			//return an error, cannot both rotate and H flip
7762		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
7763		✗	break;
7764
7765			case 26:
7766			//pivot + lit + hflip
7767		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
7768			//return error cannot pivot, lit, and flip
7769		✗	break;
7770
7771			case 28:
7772			//lit + vh flip
7773			//return an error, cannot both rotate and VH flip
7774		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7775		✗	break;
7776
7777			case 32: //gouraud
7778			//Probably not wort supporting.
7779			//stretch_blit(sbmp, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
7780			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7781		✗	break;
7782
7783			case 0:
7784			//no effect.
7785		✗	masked_blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7786		✗	rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7787		✗	break;
7788
7789			default:
7790
7791		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7792
7793			}
7794			} //end rtated, masked
7795			} //end if masked
7796
7797			else //not masked, and not stretched; just blit
7798			{
7799
7800		✗	if ( rot == 0 ) //if not rotated
7801			{
7802		✗	switch(mode)
7803			{
7804			case 1:
7805			//transparent
7806		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7807		✗	draw_trans_sprite(destBMP, subBmp, dx, dy);
7808		✗	break;
7809
7810
7811			case 2:
7812			//pivot?
7813		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7814		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7815			//Pivoting requires two more args
7816		✗	break;
7817
7818			case 3:
7819			//pivot + trans
7820		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7821		✗	pivot_sprite_trans(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7822		✗	break;
7823
7824			case 4:
7825			//flip v
7826		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7827		✗	draw_sprite_v_flip(destBMP, subBmp, dx, dy);
7828		✗	break;
7829
7830			case 5:
7831			//trans + v flip
7832		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7833		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
7834		✗	break;
7835
7836			case 6:
7837			//pivot + v flip
7838		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7839		✗	pivot_sprite_v_flip(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7840		✗	break;
7841
7842			case 8:
7843			//vlip h
7844		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7845		✗	draw_sprite_h_flip(destBMP, subBmp, dx, dy);
7846		✗	break;
7847
7848			case 9:
7849			//trans + h flip
7850		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7851		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
7852		✗	break;
7853
7854			case 10:
7855			//flip H and pivot
7856		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7857			//return error cannot pivot and h flip
7858		✗	break;
7859
7860			case 12:
7861			//vh flip
7862		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7863		✗	draw_sprite_vh_flip(destBMP, subBmp, dx, dy);
7864		✗	break;
7865
7866			case 13:
7867			//trans + vh flip
7868		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7869		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
7870		✗	break;
7871
7872			case 14:
7873			//pivot and vh flip
7874		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
7875			//return error cannot both pivot and vh flip
7876		✗	break;
7877
7878			case 16:
7879			//lit
7880		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7881		✗	draw_lit_sprite(destBMP, subBmp, dx, dy, litcolour);
7882		✗	break;
7883
7884			case 18:
7885			//pivot, lit
7886		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7887		✗	pivot_sprite_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7888		✗	break;
7889
7890			case 20:
7891			//lit + v flip
7892		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7893		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
7894		✗	break;
7895
7896			case 22:
7897			//Pivot, vflip, lit
7898		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7899		✗	pivot_sprite_v_flip_lit(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
7900		✗	break;
7901
7902			case 24:
7903			//lit + h flip
7904		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7905		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
7906		✗	break;
7907
7908			case 26:
7909			//pivot + lit + hflip
7910		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
7911			//return error cannot pivot, lit, and flip
7912		✗	break;
7913
7914			case 28:
7915			//lit + vh flip
7916		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7917		✗	draw_sprite_ex(destBMP, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
7918		✗	break;
7919
7920			case 32: //gouraud
7921			//Probably not wort supporting.
7922			//blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7923			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
7924		✗	break;
7925
7926			case 0:
7927			//no effect
7928		✗	blit(sbmp, destBMP, sx, sy, dx, dy, dw, dh);
7929		✗	break;
7930
7931
7932			default:
7933
7934		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
7935
7936
7937			}
7938			} //end if not rotated
7939
7940		✗	if ( rot != 0 ) //if rotated
7941			{
7942		✗	switch(mode)
7943			{
7944			case 1:
7945		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);//transparent
7946		✗	rotate_sprite_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7947
7948		✗	break;
7949
7950			case 2:
7951			//pivot?
7952		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7953		✗	pivot_sprite(destBMP, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
7954			//Pivoting requires two more args
7955		✗	break;
7956
7957			case 3:
7958			//pivot + trans
7959			//return an error, cannot both rotate and pivot
7960		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7961		✗	break;
7962
7963			case 4:
7964			//flip v
7965		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7966		✗	rotate_sprite_v_flip(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7967		✗	break;
7968
7969			case 5:
7970			//trans + v flip
7971		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
7972		✗	rotate_sprite_v_flip_trans(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
7973		✗	break;
7974
7975			case 6:
7976			//pivot + v flip
7977		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
7978			//return an error, cannot both rotate and pivot
7979		✗	break;
7980
7981			case 8:
7982			//flip h
7983		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
7984			//return an error, cannot both rotate and flip H
7985		✗	break;
7986
7987			case 9:
7988			//trans + h flip
7989		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
7990			//return an error, cannot rotate and flip a trans sprite
7991		✗	break;
7992
7993			case 10:
7994			//flip H and pivot
7995			//return error cannot pivot and h flip
7996		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
7997		✗	break;
7998
7999			case 12:
8000			//vh flip
8001			//return an error, cannot rotate and VH flip a trans sprite
8002		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8003		✗	break;
8004
8005			case 13:
8006			//trans + vh flip
8007			//return an error, cannot rotate and VH flip a trans sprite
8008		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8009		✗	break;
8010
8011			case 14:
8012			//pivot and vh flip
8013		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8014			//return error cannot both pivot and vh flip
8015		✗	break;
8016
8017			case 16:
8018			//lit
8019		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8020		✗	rotate_sprite_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8021		✗	break;
8022
8023			case 18:
8024			//pivot, lit
8025			//return an error, cannot both rotate and pivot
8026		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8027		✗	break;
8028
8029			case 20:
8030			//lit + vflip
8031		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8032		✗	rotate_sprite_v_flip_lit(destBMP, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8033		✗	break;
8034
8035			case 22:
8036			//Pivot, vflip, lit
8037			//return an error, cannot both rotate and pivot
8038		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8039		✗	break;
8040
8041			case 24:
8042			//lit + h flip
8043			//return an error, cannot both rotate and H flip
8044		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
8045		✗	break;
8046
8047			case 26:
8048			//pivot + lit + hflip
8049		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
8050			//return error cannot pivot, lit, and flip
8051		✗	break;
8052
8053			case 28:
8054			//lit + vh flip
8055			//return an error, cannot both rotate and VH flip
8056		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8057		✗	break;
8058
8059			case 32: //gouraud
8060			//Probably not wort supporting.
8061			//blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8062			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8063		✗	break;
8064
8065			case 0:
8066			//no effect.
8067		✗	blit(sbmp, subBmp, sx, sy, 0, 0, dw, dh);
8068		✗	rotate_sprite(destBMP, subBmp, dx, dy, degrees_to_fixed(rot));
8069		✗	break;
8070
8071			default:
8072
8073		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8074
8075			}
8076			} //end if rotated
8077			} //end if not masked
8078			} //end if not stretched
8079
8080			//cleanup
8081		✗	if(subBmp)
8082			{
8083			//script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
8084		✗	destroy_bitmap(subBmp);
8085			}
8086		✗	if (sbmp != sourceBitmap)
8087			{
8088		✗	destroy_bitmap(sbmp);
8089			}
8090			}
8091
8092
8093
8094		✗	void bmp_do_blittor(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset)
8095			{
8096			/*
8097			//sdci[1]=layer
8098			//sdci[2]=bitmap target
8099			//
8100			// -2 is the current Render Target
8101			// -1, this is the screen (framebuf).
8102			// 0: Render target 0
8103			// 1: Render target 1
8104			// 2: Render target 2
8105			// 3: Render target 3
8106			// 4: Render target 4
8107			// 5: Render target 5
8108			// 6: Render target 6
8109			// Otherwise: The pointer to a bitmap.
8110
8111			//sdci[3]=sourcex
8112			//sdci[4]=sourcey
8113			//sdci[5]=sourcew
8114			//sdci[6]=sourceh
8115			//sdci[7]=destx
8116			//sdci[8]=desty
8117			//sdci[9]=destw
8118			//sdci[10]=desth
8119			//sdci[11]=rotation/angle
8120			//scdi[12] = pivot cx
8121			//sdci[13] = pivot cy
8122			//scdi[14] = effect flags
8123			//sdci[17] Bitmap Pointer
8124
8125			// ZScript-side constant values:
8126			const int32_t BITDX_NORMAL = 0;
8127			const int32_t BITDX_TRANS = 1; //Translucent
8128			const int32_t BITDX_PIVOT = 2; //THe sprite will rotate at a specific point, instead of its center.
8129			const int32_t BITDX_HFLIP = 4; //Horizontal Flip
8130			const int32_t BITDX_VFLIP = 8; //Vertical Flip.
8131			//Note: Some modes cannot be combined. if a combination is not supported, an error
8132			// detailing this will be shown in allegro.log.
8133
8134			//scdi[15] = litcolour
8135			//The allegro docs are wrong. The params are: rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8136			//not rotate_sprite_lit(bmp, subBmp, dx, dy, degrees_to_fixed(rot));
8137
8138			//sdci[16]=mask
8139
8140			*/
8141
8142		✗	int32_t srcyoffset = yoffset, srcxoffset = xoffset;
8143		✗	int32_t bitmapIndex = sdci[2]/10000;
8144		✗	int32_t usr_bitmap_index = sdci[2]-10;
8145		✗	byte using_user_bitmap = 0;
8146			//Z_scripterrlog("bitmap index is: %d\n",bitmapIndex);
8147			//Z_scripterrlog("Blit() bitmapIndex is: %d\n", bitmapIndex);
8148			#if LOG_BMPBLIT_LEVEL > 0
8149			Z_scripterrlog("Blit() found a dest bitmap ID of: %d\n",bitmapIndex);
8150			#endif
8151		✗	if ( bitmapIndex > 10000 )
8152			{
8153		✗	bitmapIndex = bitmapIndex / 10000; //reduce if ZScript sent a raw value, such as bitmap = <int32_t> 8;
8154			}
8155		✗	if ( usr_bitmap_index > 0 && usr_bitmap_index < 10000 )
8156			{
8157		✗	bitmapIndex = usr_bitmap_index;
8158		✗	using_user_bitmap = 1;
8159		✗	srcyoffset = 0;
8160			}
8161
8162		✗	int32_t sx = sdci[3]/10000;
8163		✗	int32_t sy = sdci[4]/10000;
8164		✗	int32_t sw = sdci[5]/10000;
8165			//Z_scripterrlog("sh is: %d\n",sdci[5]/10000);
8166		✗	int32_t sh = sdci[6]/10000;
8167			//Z_scripterrlog("sh is: %d\n",sdci[6]/10000);
8168		✗	int32_t dx = sdci[7]/10000;
8169		✗	int32_t dy = sdci[8]/10000;
8170		✗	int32_t dw = sdci[9]/10000;
8171		✗	int32_t dh = sdci[10]/10000;
8172		✗	float rot = sdci[11]/10000;
8173		✗	int32_t cx = sdci[12]/10000;
8174		✗	int32_t cy = sdci[13]/10000;
8175		✗	int32_t mode = sdci[14]/10000;
8176		✗	int32_t litcolour = sdci[15]/10000;
8177		✗	bool masked = (sdci[16] != 0);
8178
8179		✗	int32_t ref = 0;
8180
8181			//These should go down farther, should they not? -V
8182			//dx = dx + xoffset;
8183			//dy = dy + yoffset;
8184
8185		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
8186		✗	if ( (bitmapIndex) != -2 && (bitmapIndex) != -1 ) srcyoffset = 0; //Don't crop.
8187			//Do we need to also check the render target and do the same thing if the
8188			//dest == -2 and the render target is not RT_SCREEN?
8189		✗	dx = dx + xoffset;
8190		✗	dy = dy + yoffset;
8191		✗	sx = sx + srcxoffset;
8192		✗	sy = sy + srcyoffset;
8193
8194		✗	ref = sdci[17];
8195			//Z_scripterrlog("bitmap->blit() ref id this frame is: %d\n", ref);
8196		✗	ref -=10;
8197			//Z_scripterrlog("bitmap->blit() modified ref id this frame is: %d\n", ref);
8198
8199
8200		✗	if ( ref <= 0 )
8201			{
8202		✗	Z_scripterrlog("bitmap->blit() wanted to use to an invalid source bitmap id: %d. Aborting.\n", ref);
8203		✗	return;
8204			}
8205		✗	BITMAP *sourceBitmap = FFCore.GetScriptBitmap(ref); //This can be the screen, as -1.
8206			#if LOG_BMPBLIT_LEVEL > 0
8207			Z_scripterrlog("bitmap->Blit() is trying to blit to ref: %d\n",sdci[17]);
8208			#endif
8209		✗	if(!sourceBitmap)
8210			{
8211		✗	Z_message("Warning: blit(%d) source bitmap contains invalid data or is not initialized.\n", ref);
8212		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
8213		✗	return;
8214			}
8215
8216		✗	BITMAP *destBMP=NULL;
8217			//zprint2("RevBlit bitmap index is: %d\n",bitmapIndex);
8218
8219		✗	switch(bitmapIndex)
8220			{
8221			case -2:
8222			{
8223		✗	int32_t curr_rt = zscriptDrawingRenderTarget->GetCurrentRenderTarget();
8224			//zprint2("current RT is: %d\n", curr_rt);
8225		✗	if ( curr_rt >= 0 && curr_rt < 7 )
8226		✗	destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); //Drawing to the current RenderTarget.
8227		✗	else destBMP = bmp; //screen
8228		✗	break;
8229			}
8230			case -1:
8231		✗	destBMP = bmp; //this is framebuf, by default
8232		✗	break;
8233			//zscriptDrawingRenderTarget->SetCurrentRenderTarget(bitmapIndex);
8234			//destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
8235			//destBMP = framebuf; //Drawing to the screen.
8236			//break;
8237
8238			//1 through 6 are the old system bitmaps (Render Targets)
8239			case 0:
8240			case 1:
8241			case 2:
8242			case 3:
8243			case 4:
8244			case 5:
8245			case 6:
8246			{
8247			//This gets a render target.
8248			//destBMP = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex); break;
8249
8250		✗	destBMP = zscriptDrawingRenderTarget->GetTargetBitmap(bitmapIndex);
8251			//sdci[18] = bitmapIndex;
8252		✗	break;
8253			}
8254			//Otherwise, we are using a user-created bitmap, so, get that pointer insted.
8255			default:
8256			{
8257		✗	destBMP = scb.script_created_bitmaps[usr_bitmap_index].u_bmp;
8258			//sdci[18] = usr_bitmap_index;
8259		✗	if ( !scb.script_created_bitmaps[usr_bitmap_index].u_bmp )
8260			{
8261		✗	Z_scripterrlog("Target for bitmap->Blit is uninitialised. Aborting.\n");
8262		✗	break;
8263			}
8264			}
8265			//FFCore.get_user_bitmap(bitmapIndex); break;
8266			}
8267
8268			#if LOG_BMPBLIT_LEVEL > 0
8269			Z_scripterrlog("bitmap->Blit() is trying to blit to dest bitmap ID: %d\n",bitmapIndex);
8270			#endif
8271
8272
8273		✗	if (!destBMP)
8274			{
8275		✗	Z_message("Warning: blit(%d) destination bitmap contains invalid data or is not initialized.\n", bitmapIndex);
8276		✗	Z_message("[Note* Deferred drawing or layering order possibly not set right.]\n");
8277		✗	return;
8278			}
8279
8280			//bugfix
8281			//sx = vbound(sx, 0, sourceBitmap->w);
8282			#if LOG_BMPBLIT_LEVEL > 0
8283			Z_scripterrlog("Blit %s is: %d\n", "sx", sx);
8284			Z_scripterrlog("Blit %s is: %d\n", "source->w", sourceBitmap->w);
8285			#endif
8286			//sy = vbound(sy, 0, sourceBitmap->h);
8287			#if LOG_BMPBLIT_LEVEL > 0
8288			Z_scripterrlog("Blit %s is: %d\n", "sy", sy);
8289			Z_scripterrlog("Blit %s is: %d\n", "source->h", sourceBitmap->h);
8290			#endif
8291			//sw = vbound(sw, 0, sourceBitmap->w - sx); //keep the w/h within range as well
8292			#if LOG_BMPBLIT_LEVEL > 0
8293			Z_scripterrlog("Blit %s is: %d\n", "sw", sw);
8294			#endif
8295			//sh = vbound(sh, 0, sourceBitmap->h - sy);
8296			#if LOG_BMPBLIT_LEVEL > 0
8297			Z_scripterrlog("Blit %s is: %d\n", "sh", sh);
8298
8299			Z_scripterrlog("Blit %s is: %d\n", "dx", dx);
8300			Z_scripterrlog("Blit %s is: %d\n", "dy", dy);
8301			Z_scripterrlog("Blit %s is: %d\n", "dh", dh);
8302			Z_scripterrlog("Blit %s is: %d\n", "dw", dw);
8303			Z_scripterrlog("Blit %s is: %d\n", "yoffset", yoffset);
8304			#endif
8305		✗	bool stretched = (sw != dw || sh != dh);
8306			//bool stretched = (sourceBitmap->w != destBMP->w || sourceBitmap->h != destBMP->h);
8307			#if LOG_BMPBLIT_LEVEL > 0
8308			Z_scripterrlog("Blit %s is: %s\n", "stretched", stretched ? "true" : "false");
8309			#endif
8310			//BITMAP *sourceBitmap = zscriptDrawingRenderTarget->GetBitmapPtr(bitmapIndex);
8311
8312
8313
8314		✗	BITMAP* newDest = sourceBitmap;
8315		✗	BITMAP* newSource = destBMP; //Flip them.
8316
8317		✗	BITMAP* subBmp = 0;
8318
8319			/* IDR what this was. -Z ( 17th April, 2019 )
8320			if ( bitmapIndex == -1 ) {
8321			blit(bmp, sourceBitmap, sx, sy, 0, 0, dw, dh);
8322			}
8323			*/
8324
8325		✗	if(rot != 0 || mode != 0)
8326			{
8327		✗	subBmp = create_bitmap_ex(8,sourceBitmap->w, sourceBitmap->h);//script_drawing_commands.AquireSubBitmap(dw, dh);
8328		✗	clear_bitmap(subBmp);
8329
8330		✗	if(!subBmp)
8331			{
8332		✗	Z_scripterrlog("bitmap->Blit failed to create a sub-bitmap to use for %s. Aborting.\n", "rotation");
8333		✗	return;
8334			}
8335			}
8336
8337		✗	if (sx + sw > destBMP->w || sy + sh > destBMP->h)
8338			{
8339		✗	newSource = create_bitmap_ex(8, sw, sh);
8340		✗	clear_bitmap(newSource);
8341		✗	blit(destBMP, newSource, sx, sy, 0, 0, std::min(destBMP->w-sx, sw), std::min(destBMP->h-sy, sh));
8342		✗	sx = 0;
8343		✗	sy = 0;
8344			}
8345			//dx = dx + xoffset; //don't do this here!
8346			//dy = dy + yoffset; //Nor this. It auto-offsets the bitmap by +56. Hmm. The fix that gleeok made isn't being applied to these functions. -Z ( 17th April, 2019 )
8347
8348		✗	if(stretched)
8349			{
8350		✗	if(masked)
8351			{ //stretched and masked
8352		✗	if ( rot == 0 )
8353			{ //if not rotated
8354		✗	switch(mode)
8355			{
8356			case 1:
8357			//transparent
8358		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8359		✗	draw_trans_sprite(newDest, subBmp, dx, dy);
8360		✗	break;
8361
8362
8363			case 2:
8364			//pivot?
8365		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8366		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8367			//Pivoting requires two more args
8368		✗	break;
8369
8370			case 3:
8371			//pivot + trans
8372		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8373		✗	pivot_sprite_trans(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8374		✗	break;
8375
8376			case 4:
8377			//flip v
8378		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8379		✗	draw_sprite_v_flip(newDest, subBmp, dx, dy);
8380		✗	break;
8381
8382			case 5:
8383			//trans + v flip
8384		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8385		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
8386		✗	break;
8387
8388			case 6:
8389			//pivot + v flip
8390		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8391		✗	pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8392		✗	break;
8393
8394			case 8:
8395			//vlip h
8396		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8397		✗	draw_sprite_h_flip(newDest, subBmp, dx, dy);
8398		✗	break;
8399
8400			case 9:
8401			//trans + h flip
8402		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8403		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
8404		✗	break;
8405
8406			case 10:
8407			//flip H and pivot
8408		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8409			//return error cannot pivot and h flip
8410		✗	break;
8411
8412			case 12:
8413			//vh flip
8414		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8415		✗	draw_sprite_vh_flip(newDest, subBmp, dx, dy);
8416		✗	break;
8417
8418			case 13:
8419			//trans + vh flip
8420		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8421		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
8422		✗	break;
8423
8424			case 14:
8425			//pivot and vh flip
8426		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8427			//return error cannot both pivot and vh flip
8428		✗	break;
8429
8430			case 16:
8431			//lit
8432		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8433		✗	draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
8434		✗	break;
8435
8436			case 18:
8437			//pivot, lit
8438		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8439		✗	pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8440		✗	break;
8441
8442			case 20:
8443			//lit + v flip
8444		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8445		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
8446		✗	break;
8447
8448			case 22:
8449			//Pivot, vflip, lit
8450		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8451		✗	pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8452		✗	break;
8453
8454			case 24:
8455			//lit + h flip
8456		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8457		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
8458		✗	break;
8459
8460			case 26:
8461			//pivot + lit + hflip
8462		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
8463			//return error cannot pivot, lit, and flip
8464		✗	break;
8465
8466			case 28:
8467			//lit + vh flip
8468		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8469		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
8470		✗	break;
8471
8472			case 32: //gouraud
8473			//Probably not wort supporting.
8474			//masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8475			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8476		✗	break;
8477
8478			case 0:
8479			//no effect
8480		✗	masked_stretch_blit(newSource, newDest, sx, sy, sw, sh, dx, dy, dw, dh);
8481		✗	break;
8482
8483
8484			default:
8485		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8486
8487
8488			}
8489			} //end if not rotated
8490
8491		✗	if ( rot != 0 ) //if rotated
8492			{
8493		✗	switch(mode)
8494			{
8495			case 1:
8496			//transparent
8497		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8498		✗	rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8499
8500		✗	break;
8501
8502			case 2:
8503			//pivot?
8504		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8505		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8506			//Pivoting requires two more args
8507		✗	break;
8508
8509			case 3:
8510			//pivot + trans
8511			//return an error, cannot both rotate and pivot
8512		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8513		✗	break;
8514
8515			case 4:
8516			//flip v
8517		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8518		✗	rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8519		✗	break;
8520
8521			case 5:
8522			//trans + v flip
8523		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8524		✗	rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8525		✗	break;
8526
8527			case 6:
8528			//pivot + v flip
8529		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8530			//return an error, cannot both rotate and pivot
8531		✗	break;
8532
8533			case 8:
8534			//flip h
8535		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
8536			//return an error, cannot both rotate and flip H
8537		✗	break;
8538
8539			case 9:
8540			//trans + h flip
8541		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
8542			//return an error, cannot rotate and flip a trans sprite
8543		✗	break;
8544
8545			case 10:
8546			//flip H and pivot
8547			//return error cannot pivot and h flip
8548		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8549		✗	break;
8550
8551			case 12:
8552			//vh flip
8553			//return an error, cannot rotate and VH flip a trans sprite
8554		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8555		✗	break;
8556
8557			case 13:
8558			//trans + vh flip
8559			//return an error, cannot rotate and VH flip a trans sprite
8560		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8561		✗	break;
8562
8563			case 14:
8564			//pivot and vh flip
8565		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8566			//return error cannot both pivot and vh flip
8567		✗	break;
8568
8569			case 16:
8570			//lit
8571		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8572		✗	rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8573		✗	break;
8574
8575			case 18:
8576			//pivot, lit
8577			//return an error, cannot both rotate and pivot
8578		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8579		✗	break;
8580
8581			case 20:
8582			//lit + vflip
8583		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8584		✗	rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8585		✗	break;
8586
8587			case 22:
8588			//Pivot, vflip, lit
8589			//return an error, cannot both rotate and pivot
8590		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8591		✗	break;
8592
8593			case 24:
8594			//lit + h flip
8595			//return an error, cannot both rotate and H flip
8596		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
8597		✗	break;
8598
8599			case 26:
8600			//pivot + lit + hflip
8601		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
8602			//return error cannot pivot, lit, and flip
8603		✗	break;
8604
8605			case 28:
8606			//lit + vh flip
8607			//return an error, cannot both rotate and VH flip
8608		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8609		✗	break;
8610
8611			case 32: //gouraud
8612			//Probably not wort supporting.
8613			//masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8614			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8615		✗	break;
8616
8617			case 0:
8618			//no effect.
8619		✗	masked_stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8620		✗	rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8621		✗	break;
8622
8623			default:
8624		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8625
8626			}
8627			}
8628			} //end if stretched and masked
8629
8630			else //stretched, not masked
8631			{
8632
8633
8634		✗	if ( rot == 0 ) //if not rotated
8635			{
8636		✗	switch(mode)
8637			{
8638			case 1:
8639			//transparent
8640		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8641		✗	draw_trans_sprite(newDest, subBmp, dx, dy);
8642		✗	break;
8643
8644
8645			case 2:
8646			//pivot?
8647		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8648		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8649			//Pivoting requires two more args
8650		✗	break;
8651
8652			case 3:
8653			//pivot + trans
8654		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8655		✗	pivot_sprite_trans(newDest, subBmp, dx,dy, cx, cy, degrees_to_fixed(rot));
8656		✗	break;
8657
8658			case 4:
8659			//flip v
8660		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8661		✗	draw_sprite_v_flip(newDest, subBmp, dx, dy);
8662		✗	break;
8663
8664			case 5:
8665			//trans + v flip
8666		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8667		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
8668		✗	break;
8669
8670			case 6:
8671			//pivot + v flip
8672		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8673		✗	pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8674		✗	break;
8675
8676			case 8:
8677			//vlip h
8678		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8679		✗	draw_sprite_h_flip(newDest, subBmp, dx, dy);
8680		✗	break;
8681
8682			case 9:
8683			//trans + h flip
8684		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8685		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
8686		✗	break;
8687
8688			case 10:
8689			//flip H and pivot
8690		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8691			//return error cannot pivot and h flip
8692		✗	break;
8693
8694			case 12:
8695			//vh flip
8696		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8697		✗	draw_sprite_vh_flip(newDest, subBmp, dx, dy);
8698		✗	break;
8699
8700			case 13:
8701			//trans + vh flip
8702		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8703		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
8704		✗	break;
8705
8706			case 14:
8707			//pivot and vh flip
8708		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8709			//return error cannot both pivot and vh flip
8710		✗	break;
8711
8712			case 16:
8713			//lit
8714		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8715		✗	draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
8716		✗	break;
8717
8718			case 18:
8719			//pivot, lit
8720		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8721		✗	pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8722		✗	break;
8723
8724			case 20:
8725			//lit + v flip
8726		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8727		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
8728		✗	break;
8729
8730			case 22:
8731			//Pivot, vflip, lit
8732		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8733		✗	pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
8734		✗	break;
8735
8736			case 24:
8737			//lit + h flip
8738		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8739		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
8740		✗	break;
8741
8742			case 26:
8743			//pivot + lit + hflip
8744		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
8745			//return error cannot pivot, lit, and flip
8746		✗	break;
8747
8748			case 28:
8749			//lit + vh flip
8750		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8751		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
8752		✗	break;
8753
8754			case 32: //gouraud
8755			//Probably not wort supporting.
8756			//stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8757			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8758		✗	break;
8759
8760			case 0:
8761			//no effect
8762		✗	stretch_blit(newSource, newDest, sx, sy, sw, sh, dx, dy, dw, dh);
8763		✗	break;
8764
8765
8766			default:
8767		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8768
8769
8770			}
8771			} //end if not rotated
8772
8773		✗	if ( rot != 0 ) //if rotated
8774			{
8775		✗	switch(mode)
8776			{
8777			case 1:
8778		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
8779		✗	rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8780
8781		✗	break;
8782
8783			case 2:
8784			//pivot?
8785		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8786		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8787			//Pivoting requires two more args
8788		✗	break;
8789
8790			case 3:
8791			//pivot + trans
8792			//return an error, cannot both rotate and pivot
8793		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8794		✗	break;
8795
8796			case 4:
8797			//flip v
8798		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8799		✗	rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8800		✗	break;
8801
8802			case 5:
8803			//trans + v flip
8804		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8805		✗	rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8806		✗	break;
8807
8808			case 6:
8809			//pivot + v flip
8810		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8811			//return an error, cannot both rotate and pivot
8812		✗	break;
8813
8814			case 8:
8815			//flip h
8816		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
8817			//return an error, cannot both rotate and flip H
8818		✗	break;
8819
8820			case 9:
8821			//trans + h flip
8822		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
8823			//return an error, cannot rotate and flip a trans sprite
8824		✗	break;
8825
8826			case 10:
8827			//flip H and pivot
8828			//return error cannot pivot and h flip
8829		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8830		✗	break;
8831
8832			case 12:
8833			//vh flip
8834			//return an error, cannot rotate and VH flip a trans sprite
8835		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8836		✗	break;
8837
8838			case 13:
8839			//trans + vh flip
8840			//return an error, cannot rotate and VH flip a trans sprite
8841		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
8842		✗	break;
8843
8844			case 14:
8845			//pivot and vh flip
8846		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8847			//return error cannot both pivot and vh flip
8848		✗	break;
8849
8850			case 16:
8851			//lit
8852		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
8853		✗	rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8854		✗	break;
8855
8856			case 18:
8857			//pivot, lit
8858			//return an error, cannot both rotate and pivot
8859		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
8860		✗	break;
8861
8862			case 20:
8863			//lit + vflip
8864		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);//transparent
8865		✗	rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
8866		✗	break;
8867
8868			case 22:
8869			//Pivot, vflip, lit
8870			//return an error, cannot both rotate and pivot
8871		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
8872		✗	break;
8873
8874			case 24:
8875			//lit + h flip
8876			//return an error, cannot both rotate and H flip
8877		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
8878		✗	break;
8879
8880			case 26:
8881			//pivot + lit + hflip
8882		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
8883			//return error cannot pivot, lit, and flip
8884		✗	break;
8885
8886			case 28:
8887			//lit + vh flip
8888			//return an error, cannot both rotate and VH flip
8889		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8890		✗	break;
8891
8892			case 32: //gouraud
8893			//Probably not wort supporting.
8894			//stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8895			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
8896		✗	break;
8897
8898			case 0:
8899			//no effect.
8900		✗	stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
8901		✗	rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
8902		✗	break;
8903
8904			default:
8905		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
8906
8907			}
8908			}
8909
8910			} //end if stretched, but not masked
8911			}
8912			else //not stretched
8913			{
8914
8915		✗	if(masked) //if masked, but not stretched
8916			{
8917
8918		✗	if ( rot == 0 ) //if not rotated
8919			{
8920		✗	switch(mode)
8921			{
8922			case 1:
8923			//transparent
8924		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8925		✗	draw_trans_sprite(newDest, subBmp, dx, dy);
8926		✗	break;
8927
8928
8929			case 2:
8930			//pivot?
8931		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8932		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8933			//Pivoting requires two more args
8934		✗	break;
8935
8936			case 3:
8937			//pivot + trans
8938		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8939		✗	pivot_sprite_trans(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8940		✗	break;
8941
8942			case 4:
8943			//flip v
8944		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8945		✗	draw_sprite_v_flip(newDest, subBmp, dx, dy);
8946		✗	break;
8947
8948			case 5:
8949			//trans + v flip
8950		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8951		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
8952		✗	break;
8953
8954			case 6:
8955			//pivot + v flip
8956		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8957		✗	pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
8958		✗	break;
8959
8960			case 8:
8961			//vlip h
8962		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8963		✗	draw_sprite_h_flip(newDest, subBmp, dx, dy);
8964		✗	break;
8965
8966			case 9:
8967			//trans + h flip
8968		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8969		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
8970		✗	break;
8971
8972			case 10:
8973			//flip H and pivot
8974		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
8975			//return error cannot pivot and h flip
8976		✗	break;
8977
8978			case 12:
8979			//vh flip
8980		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8981		✗	draw_sprite_vh_flip(newDest, subBmp, dx, dy);
8982		✗	break;
8983
8984			case 13:
8985			//trans + vh flip
8986		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8987		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
8988		✗	break;
8989
8990			case 14:
8991			//pivot and vh flip
8992		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
8993			//return error cannot both pivot and vh flip
8994		✗	break;
8995
8996			case 16:
8997			//lit
8998		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
8999		✗	draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
9000		✗	break;
9001
9002			case 18:
9003			//pivot, lit
9004		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9005		✗	pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9006		✗	break;
9007
9008			case 20:
9009			//lit + v flip
9010		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9011		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
9012		✗	break;
9013
9014			case 22:
9015			//Pivot, vflip, lit
9016		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9017		✗	pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9018		✗	break;
9019
9020			case 24:
9021			//lit + h flip
9022		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9023		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
9024		✗	break;
9025
9026			case 26:
9027			//pivot + lit + hflip
9028		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
9029			//return error cannot pivot, lit, and flip
9030		✗	break;
9031
9032			case 28:
9033			//lit + vh flip
9034		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9035		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
9036		✗	break;
9037
9038			case 32: //gouraud
9039			//Probably not wort supporting.
9040			//stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
9041			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9042		✗	break;
9043
9044			case 0:
9045			//no effect
9046		✗	masked_blit(newSource, newDest, sx, sy, dx, dy, dw, dh);
9047		✗	break;
9048
9049
9050			default:
9051		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9052
9053
9054			}
9055			} //end if not rotated
9056
9057		✗	if ( rot != 0 ) //if rotated
9058			{
9059		✗	switch(mode)
9060			{
9061			case 1:
9062		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh); //transparent
9063		✗	rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9064
9065		✗	break;
9066
9067			case 2:
9068			//pivot?
9069		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9070		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9071			//Pivoting requires two more args
9072		✗	break;
9073
9074			case 3:
9075			//pivot + trans
9076			//return an error, cannot both rotate and pivot
9077		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9078		✗	break;
9079
9080			case 4:
9081			//flip v
9082		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9083		✗	rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9084		✗	break;
9085
9086			case 5:
9087		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh); //trans + v flip
9088		✗	rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9089		✗	break;
9090
9091			case 6:
9092			//pivot + v flip
9093		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9094			//return an error, cannot both rotate and pivot
9095		✗	break;
9096
9097			case 8:
9098			//flip h
9099		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
9100			//return an error, cannot both rotate and flip H
9101		✗	break;
9102
9103			case 9:
9104			//trans + h flip
9105		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
9106			//return an error, cannot rotate and flip a trans sprite
9107		✗	break;
9108
9109			case 10:
9110			//flip H and pivot
9111			//return error cannot pivot and h flip
9112		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
9113		✗	break;
9114
9115			case 12:
9116			//vh flip
9117			//return an error, cannot rotate and VH flip a trans sprite
9118		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9119		✗	break;
9120
9121			case 13:
9122			//trans + vh flip
9123			//return an error, cannot rotate and VH flip a trans sprite
9124		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9125		✗	break;
9126
9127			case 14:
9128			//pivot and vh flip
9129		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9130			//return error cannot both pivot and vh flip
9131		✗	break;
9132
9133			case 16:
9134			//lit
9135		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9136		✗	rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9137		✗	break;
9138
9139			case 18:
9140			//pivot, lit
9141			//return an error, cannot both rotate and pivot
9142		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9143		✗	break;
9144
9145			case 20:
9146			//lit + vflip
9147		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9148		✗	rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9149		✗	break;
9150
9151			case 22:
9152			//Pivot, vflip, lit
9153			//return an error, cannot both rotate and pivot
9154		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9155		✗	break;
9156
9157			case 24:
9158			//lit + h flip
9159			//return an error, cannot both rotate and H flip
9160		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
9161		✗	break;
9162
9163			case 26:
9164			//pivot + lit + hflip
9165		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
9166			//return error cannot pivot, lit, and flip
9167		✗	break;
9168
9169			case 28:
9170			//lit + vh flip
9171			//return an error, cannot both rotate and VH flip
9172		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
9173		✗	break;
9174
9175			case 32: //gouraud
9176			//Probably not wort supporting.
9177			//stretch_blit(newSource, subBmp, sx, sy, sw, sh, 0, 0, dw, dh);
9178			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9179		✗	break;
9180
9181			case 0:
9182			//no effect.
9183		✗	masked_blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9184		✗	rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9185		✗	break;
9186
9187			default:
9188		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9189
9190			}
9191			} //end rtated, masked
9192			} //end if masked
9193
9194			else //not masked, and not stretched; just blit
9195			{
9196
9197		✗	if ( rot == 0 ) //if not rotated
9198			{
9199		✗	switch(mode)
9200			{
9201			case 1:
9202			//transparent
9203		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9204		✗	draw_trans_sprite(newDest, subBmp, dx, dy);
9205		✗	break;
9206
9207
9208			case 2:
9209			//pivot?
9210		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9211		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9212			//Pivoting requires two more args
9213		✗	break;
9214
9215			case 3:
9216			//pivot + trans
9217		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9218		✗	pivot_sprite_trans(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9219		✗	break;
9220
9221			case 4:
9222			//flip v
9223		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9224		✗	draw_sprite_v_flip(newDest, subBmp, dx, dy);
9225		✗	break;
9226
9227			case 5:
9228			//trans + v flip
9229		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9230		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_V_FLIP);
9231		✗	break;
9232
9233			case 6:
9234			//pivot + v flip
9235		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9236		✗	pivot_sprite_v_flip(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9237		✗	break;
9238
9239			case 8:
9240			//vlip h
9241		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9242		✗	draw_sprite_h_flip(newDest, subBmp, dx, dy);
9243		✗	break;
9244
9245			case 9:
9246			//trans + h flip
9247		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9248		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_H_FLIP);
9249		✗	break;
9250
9251			case 10:
9252			//flip H and pivot
9253		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
9254			//return error cannot pivot and h flip
9255		✗	break;
9256
9257			case 12:
9258			//vh flip
9259		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9260		✗	draw_sprite_vh_flip(newDest, subBmp, dx, dy);
9261		✗	break;
9262
9263			case 13:
9264			//trans + vh flip
9265		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9266		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_TRANS, DRAW_SPRITE_VH_FLIP);
9267		✗	break;
9268
9269			case 14:
9270			//pivot and vh flip
9271		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
9272			//return error cannot both pivot and vh flip
9273		✗	break;
9274
9275			case 16:
9276			//lit
9277		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9278		✗	draw_lit_sprite(newDest, subBmp, dx, dy, litcolour);
9279		✗	break;
9280
9281			case 18:
9282			//pivot, lit
9283		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9284		✗	pivot_sprite_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9285		✗	break;
9286
9287			case 20:
9288			//lit + v flip
9289		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9290		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_V_FLIP);
9291		✗	break;
9292
9293			case 22:
9294			//Pivot, vflip, lit
9295		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9296		✗	pivot_sprite_v_flip_lit(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot),litcolour);
9297		✗	break;
9298
9299			case 24:
9300			//lit + h flip
9301		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9302		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_H_FLIP);
9303		✗	break;
9304
9305			case 26:
9306			//pivot + lit + hflip
9307		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot, Flip, and Lit.\n", bitmapIndex);
9308			//return error cannot pivot, lit, and flip
9309		✗	break;
9310
9311			case 28:
9312			//lit + vh flip
9313		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9314		✗	draw_sprite_ex(newDest, subBmp, dx, dy, DRAW_SPRITE_LIT, DRAW_SPRITE_VH_FLIP);
9315		✗	break;
9316
9317			case 32: //gouraud
9318			//Probably not wort supporting.
9319			//blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9320			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9321		✗	break;
9322
9323			case 0:
9324			//no effect
9325		✗	blit(newSource, newDest, sx, sy, dx, dy, dw, dh);
9326		✗	break;
9327
9328
9329			default:
9330		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9331
9332
9333			}
9334			} //end if not rotated
9335
9336		✗	if ( rot != 0 ) //if rotated
9337			{
9338		✗	switch(mode)
9339			{
9340			case 1:
9341		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);//transparent
9342		✗	rotate_sprite_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9343
9344		✗	break;
9345
9346			case 2:
9347			//pivot?
9348		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9349		✗	pivot_sprite(newDest, subBmp, dx, dy, cx, cy, degrees_to_fixed(rot));
9350			//Pivoting requires two more args
9351		✗	break;
9352
9353			case 3:
9354			//pivot + trans
9355			//return an error, cannot both rotate and pivot
9356		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9357		✗	break;
9358
9359			case 4:
9360			//flip v
9361		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9362		✗	rotate_sprite_v_flip(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9363		✗	break;
9364
9365			case 5:
9366			//trans + v flip
9367		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9368		✗	rotate_sprite_v_flip_trans(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9369		✗	break;
9370
9371			case 6:
9372			//pivot + v flip
9373		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9374			//return an error, cannot both rotate and pivot
9375		✗	break;
9376
9377			case 8:
9378			//flip h
9379		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rorate and H-Flip.\n", bitmapIndex);
9380			//return an error, cannot both rotate and flip H
9381		✗	break;
9382
9383			case 9:
9384			//trans + h flip
9385		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot Rotate and Flip a Trans Sprite.\n", bitmapIndex);
9386			//return an error, cannot rotate and flip a trans sprite
9387		✗	break;
9388
9389			case 10:
9390			//flip H and pivot
9391			//return error cannot pivot and h flip
9392		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and H-Flip.\n", bitmapIndex);
9393		✗	break;
9394
9395			case 12:
9396			//vh flip
9397			//return an error, cannot rotate and VH flip a trans sprite
9398		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9399		✗	break;
9400
9401			case 13:
9402			//trans + vh flip
9403			//return an error, cannot rotate and VH flip a trans sprite
9404		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and VH-Flip.\n", bitmapIndex);
9405		✗	break;
9406
9407			case 14:
9408			//pivot and vh flip
9409		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9410			//return error cannot both pivot and vh flip
9411		✗	break;
9412
9413			case 16:
9414			//lit
9415		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9416		✗	rotate_sprite_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9417		✗	break;
9418
9419			case 18:
9420			//pivot, lit
9421			//return an error, cannot both rotate and pivot
9422		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rorate.\n", bitmapIndex);
9423		✗	break;
9424
9425			case 20:
9426			//lit + vflip
9427		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9428		✗	rotate_sprite_v_flip_lit(newDest, subBmp, dx, dy, degrees_to_fixed(rot),litcolour);
9429		✗	break;
9430
9431			case 22:
9432			//Pivot, vflip, lit
9433			//return an error, cannot both rotate and pivot
9434		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Rotate.\n", bitmapIndex);
9435		✗	break;
9436
9437			case 24:
9438			//lit + h flip
9439			//return an error, cannot both rotate and H flip
9440		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Rotate and H-Flip.\n", bitmapIndex);
9441		✗	break;
9442
9443			case 26:
9444			//pivot + lit + hflip
9445		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and Flip a Lit Sprite.\n", bitmapIndex);
9446			//return error cannot pivot, lit, and flip
9447		✗	break;
9448
9449			case 28:
9450			//lit + vh flip
9451			//return an error, cannot both rotate and VH flip
9452		✗	Z_message("Warning: Screen->DrawBitmap(%d) cannot both Pivot and VH-Flip.\n", bitmapIndex);
9453		✗	break;
9454
9455			case 32: //gouraud
9456			//Probably not wort supporting.
9457			//blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9458			//draw_gouraud_sprite(BITMAP *bmp, BITMAP *sprite, int32_t x, int32_t y, int32_t c1, int32_t c2, int32_t c3, int32_t c4);
9459		✗	break;
9460
9461			case 0:
9462			//no effect.
9463		✗	blit(newSource, subBmp, sx, sy, 0, 0, dw, dh);
9464		✗	rotate_sprite(newDest, subBmp, dx, dy, degrees_to_fixed(rot));
9465		✗	break;
9466
9467			default:
9468		✗	return Z_message("Warning: Screen->DrawBitmap(%d) mode flags not possible in this combination!\n", bitmapIndex);
9469
9470			}
9471			} //end if rotated
9472			} //end if not masked
9473			} //end if not stretched
9474
9475			//cleanup
9476		✗	if(subBmp)
9477			{
9478			//script_drawing_commands.ReleaseSubBitmap(subBmp); //purge the temporary bitmap.
9479		✗	destroy_bitmap(subBmp);
9480			}
9481		✗	if(newSource != destBMP)
9482			{
9483		✗	destroy_bitmap(newSource);
9484			}
9485			}
9486
9487
9488		✗	void bmp_do_drawquad3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
9489			{
9490
9491			//sdci[1]=layer
9492			//sdci[2]=pos[12]
9493			//sdci[3]=uv[8]
9494			//sdci[4]=color[4]
9495			//sdci[5]=size[2]
9496			//sdci[6]=flip
9497			//sdci[7]=tile/combo
9498			//sdci[8]=polytype
9499			//sdci[9] = other bitmap as texture
9500			//sdci[17] Bitmap Pointer
9501		✗	if ( sdci[17] <= 0 )
9502			{
9503		✗	Z_scripterrlog("bitmap->Quad3D() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
9504		✗	return;
9505			}
9506		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9507		✗	if ( refbmp == NULL ) return;
9508
9509		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
9510
9511		✗	if(!v_ptr)
9512			{
9513		✗	al_trace("Quad3d: Vector pointer is null! Internal error. \n");
9514		✗	return;
9515			}
9516
9517		✗	std::vector<int32_t> &v = *v_ptr;
9518
9519		✗	if(v.empty())
9520		✗	return;
9521
9522		✗	int32_t* pos = &v[0];
9523		✗	int32_t* uv = &v[12];
9524		✗	int32_t* col = &v[20];
9525		✗	int32_t* size = &v[24];
9526
9527		✗	int32_t w = size[0]; //magic numerical constants... yuck.
9528		✗	int32_t h = size[1];
9529		✗	int32_t flip = (sdci[6]/10000)&3;
9530		✗	int32_t tile = sdci[7]/10000;
9531		✗	int32_t polytype = sdci[8]/10000;
9532		✗	int32_t quad_render_source = sdci[9]-10;
9533		✗	Z_scripterrlog("Quad3D texture is %d\n", quad_render_source);
9534
9535		✗	polytype = vbound(polytype, 0, 14);
9536
9537		✗	int32_t tex_width = w*16;
9538		✗	int32_t tex_height = h*16;
9539
9540		✗	bool mustDestroyBmp = false;
9541		✗	BITMAP *tex=NULL;
9542
9543
9544		✗	bool tex_is_bitmap = ( sdci[9] != 0 );
9545			//Z_scripterrlog("sdci[9] is %d\n", quad_render_source);
9546			//Z_scripterrlog("sdci[17] is %d\n", sdci[17]-10);
9547			BITMAP *bmptexture;
9548
9549		✗	if ( tex_is_bitmap ) bmptexture = FFCore.GetScriptBitmap(quad_render_source);
9550
9551		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
9552
9553
9554		✗	if ( !tex_is_bitmap )
9555			{
9556		✗	tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
9557
9558		✗	if(!tex)
9559			{
9560		✗	mustDestroyBmp = true;
9561		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
9562		✗	clear_bitmap(tex);
9563			}
9564		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
9565			{
9566		✗	Z_message("Quad3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
9567		✗	return; //non power of two error
9568			}
9569		✗	if(tile > 0) // TILE
9570			{
9571		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
9572			}
9573			else // COMBO
9574			{
9575		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
9576		✗	const int32_t tiletodraw = combo_tile(c, 0, 0);
9577		✗	flip = flip ^ c.flip;
9578
9579		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
9580			}
9581
9582		✗	V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9583		✗	V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9584		✗	V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9585		✗	V3D_f V4 = { static_cast<float>(pos[9]+xoffset), static_cast<float>(pos[10]+yoffset), static_cast<float>(pos[11]), static_cast<float>(uv[6]), static_cast<float>(uv[7]), col[3] };
9586
9587		✗	quad3d_f(refbmp, polytype, tex, &V1, &V2, &V3, &V4);
9588		✗	if(mustDestroyBmp)
9589		✗	destroy_bitmap(tex);
9590			}
9591			else
9592			{
9593
9594		✗	if ( !bmptexture )
9595			{
9596		✗	Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Quad3D()");
9597		✗	tex_is_bitmap = 0;
9598		✗	return;
9599			}
9600		✗	if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9601		✗	if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9602		✗	if ( !isPowerOfTwo(h) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", h);
9603		✗	if ( !isPowerOfTwo(w) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Quad3D is not a POWER OF TWO.\nTextels may render improperly!\n", w);
9604
9605		✗	V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9606		✗	V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9607		✗	V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9608		✗	V3D_f V4 = { static_cast<float>(pos[9]+xoffset), static_cast<float>(pos[10]+yoffset), static_cast<float>(pos[11]), static_cast<float>(uv[6]), static_cast<float>(uv[7]), col[3] };
9609
9610		✗	BITMAP *foo = create_bitmap_ex(8, 256, 176);
9611
9612			//quad3d_f(refbmp, polytype, foo, &V1, &V2, &V3, &V4);
9613		✗	quad3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3, &V4);
9614		✗	destroy_bitmap(foo);
9615
9616			}
9617
9618
9619
9620			}
9621
9622
9623
9624		✗	void bmp_do_drawtriangle3dr(BITMAP *bmp, int32_t i, int32_t *sdci, int32_t xoffset, int32_t yoffset)
9625			{
9626			//sdci[1]=layer
9627			//sdci[2]=pos[9]
9628			//sdci[3]=uv[6]
9629			//sdci[4]=color[3]
9630			//sdci[5]=size[2]
9631			//sdci[6]=flip
9632			//sdci[7]=tile/combo
9633			//sdci[8]=polytype
9634			//sdci[9] bitmap as texture
9635			//sdci[17] Bitmap Pointer
9636		✗	if ( sdci[17] <= 0 )
9637			{
9638		✗	Z_scripterrlog("bitmap->Triangle3D() wanted to write to an invalid bitmap id: %d. Aborting.\n", sdci[17]);
9639		✗	return;
9640			}
9641		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9642		✗	if ( refbmp == NULL ) return;
9643
9644		✗	std::vector<int32_t>* v_ptr = (std::vector<int32_t>*)script_drawing_commands[i].GetPtr();
9645
9646		✗	if(!v_ptr)
9647			{
9648		✗	al_trace("bitmap->Triangle3d: Vector pointer is null! Internal error. \n");
9649		✗	return;
9650			}
9651
9652		✗	std::vector<int32_t> &v = *v_ptr;
9653
9654		✗	if(v.empty())
9655		✗	return;
9656
9657		✗	int32_t* pos = &v[0];
9658		✗	int32_t* uv = &v[9];
9659		✗	int32_t* col = &v[15];
9660		✗	int32_t* size = &v[18];
9661
9662		✗	int32_t w = size[0]; //magic numerical constants... yuck.
9663		✗	int32_t h = size[1];
9664		✗	int32_t flip = (sdci[6]/10000)&3;
9665		✗	int32_t tile = sdci[7]/10000;
9666		✗	int32_t polytype = sdci[8]/10000;
9667		✗	int32_t quad_render_source = sdci[9]-10;
9668		✗	polytype = vbound(polytype, 0, 14);
9669
9670		✗	if(((w-1) & w) != 0 || ((h-1) & h) != 0)
9671			{
9672		✗	Z_message("bitmap->Triangle3d() : Args h, w, must be in powers of two! Power of 2 error with %i, %i.", w, h);
9673		✗	return; //non power of two error
9674			}
9675
9676		✗	int32_t tex_width = w*16;
9677		✗	int32_t tex_height = h*16;
9678
9679		✗	bool mustDestroyBmp = false;
9680		✗	BITMAP *tex = script_drawing_commands.GetSmallTextureBitmap(w,h);
9681
9682		✗	if(!tex)
9683			{
9684		✗	mustDestroyBmp = true;
9685		✗	tex = create_bitmap_ex(8, tex_width, tex_height);
9686		✗	clear_bitmap(tex);
9687			}
9688
9689		✗	bool tex_is_bitmap = ( sdci[9] != 0 );
9690		✗	BITMAP *bmptexture=NULL;
9691		✗	if ( tex_is_bitmap )
9692			{
9693		✗	bmptexture = FFCore.GetScriptBitmap(quad_render_source);
9694		✗	if ( !bmptexture )
9695			{
9696		✗	Z_scripterrlog("Bitmap pointer used as a texture in %s is uninitialised.\n Defaulting to using a tile as a texture.\n", "bitmap->Triangle3()");
9697		✗	tex_is_bitmap = 0;
9698			}
9699			}
9700
9701		✗	if ( !tex_is_bitmap )
9702			{
9703		✗	if(tile > 0) // TILE
9704			{
9705		✗	TileHelper::OverTile(tex, tile, 0, 0, w, h, col[0], flip);
9706			}
9707			else // COMBO
9708			{
9709		✗	const newcombo & c = combobuf[ vbound(abs(tile), 0, 0xffff) ];
9710		✗	const int32_t tiletodraw = combo_tile(c, 0, 0);
9711		✗	flip = flip ^ c.flip;
9712
9713		✗	TileHelper::OldPutTile(tex, tiletodraw, 0, 0, w, h, col[0], flip);
9714			}
9715
9716		✗	V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9717		✗	V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9718		✗	V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9719
9720		✗	triangle3d_f(refbmp, polytype, tex, &V1, &V2, &V3);
9721			}
9722			else
9723			{
9724		✗	if ( !isPowerOfTwo(bmptexture->h) ) Z_scripterrlog("HEIGHT of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9725		✗	if ( !isPowerOfTwo(bmptexture->w) ) Z_scripterrlog("WIDTH of Bitmap ( pointer %d ) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", quad_render_source);
9726		✗	if ( !isPowerOfTwo(w) ) Z_scripterrlog("WIDTH ARG (%d) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", w);
9727		✗	if ( !isPowerOfTwo(h) ) Z_scripterrlog("HEIGHT ARG (%d) provided as a render source for bitmap->Triangle3D is not a POWER OF TWO.\nTextels may render improperly!\n", h);
9728
9729		✗	V3D_f V1 = { static_cast<float>(pos[0]+xoffset), static_cast<float>(pos[1] +yoffset), static_cast<float>(pos[2]), static_cast<float>(uv[0]), static_cast<float>(uv[1]), col[0] };
9730		✗	V3D_f V2 = { static_cast<float>(pos[3]+xoffset), static_cast<float>(pos[4] +yoffset), static_cast<float>(pos[5]), static_cast<float>(uv[2]), static_cast<float>(uv[3]), col[1] };
9731		✗	V3D_f V3 = { static_cast<float>(pos[6]+xoffset), static_cast<float>(pos[7] +yoffset), static_cast<float>(pos[8]), static_cast<float>(uv[4]), static_cast<float>(uv[5]), col[2] };
9732
9733		✗	triangle3d_f(refbmp, polytype, bmptexture, &V1, &V2, &V3);
9734
9735
9736			}
9737		✗	if(mustDestroyBmp)
9738		✗	destroy_bitmap(tex);
9739
9740			}
9741
9742
9743		✗	bool is_layer_transparent(const mapscr& m, int32_t layer)
9744			{
9745		✗	layer = vbound(layer, 0, 5);
9746		✗	return m.layeropacity[layer] == 128;
9747			}
9748
9749		✗	mapscr *getmapscreen(int32_t map_index, int32_t screen_index, int32_t layer) //returns NULL for invalid or non-existent layer
9750			{
9751			mapscr *base_screen;
9752		✗	int32_t index = map_index*MAPSCRS+screen_index;
9753
9754		✗	if((uint32_t)layer > 6 || (uint32_t)index >= TheMaps.size())
9755		✗	return NULL;
9756
9757		✗	if(layer != 0)
9758			{
9759		✗	layer = layer - 1;
9760
9761		✗	base_screen=&(TheMaps[index]);
9762
9763		✗	if(base_screen->layermap[layer]==0)
9764		✗	return NULL;
9765
9766		✗	index=(base_screen->layermap[layer]-1)*MAPSCRS+base_screen->layerscreen[layer];
9767
9768		✗	if((uint32_t)index >= TheMaps.size()) // Might as well make sure
9769		✗	return NULL;
9770			}
9771
9772		✗	return &(TheMaps[index]);
9773			}
9774
9775		✗	void draw_mapscr(BITMAP *b, const mapscr& m, int32_t x, int32_t y, bool transparent)
9776			{
9777		✗	for(int32_t i(0); i < 176; ++i)
9778			{
9779		✗	const int32_t x2 = ((i&15)<<4) + x;
9780		✗	const int32_t y2 = (i&0xF0) + y;
9781
9782			//const newcombo & c = combobuf[ m.data[i] ];
9783			/*
9784			newcombo c = combobuf[m.data[i]];
9785			int32_t csets[4];
9786			int32_t cofs = c.csets&15;
9787
9788			if(cofs&8)
9789			cofs |= ~int32_t(0xF);
9790
9791			for(int32_t i=0; i<4; ++i)
9792			csets[i] = c.csets&(16<<i) ? cset + cofs : cset;
9793
9794
9795			const int32_t tile = combo_tile(c, x2, y2);
9796			*/
9797
9798		✗	if(transparent)
9799			{
9800			//void overcomboblocktranslucent(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h, int32_t opacity)
9801		✗	overcomboblocktranslucent(b, x2, y2, m.data[i], m.cset[i], 1, 1, 128);
9802			//overtiletranslucent16(b, tile, x2, y2, m.cset[i], c.flip, 128);
9803			}
9804			else
9805			{
9806			//overcomboblock(BITMAP *dest, int32_t x, int32_t y, int32_t cmbdat, int32_t cset, int32_t w, int32_t h)
9807		✗	overcomboblock(b, x2, y2, m.data[i], m.cset[i], 1, 1);
9808			//overtile16(b, tile, x2, y2, m.cset[i], c.flip);
9809			}
9810			}
9811			}
9812
9813		✗	void draw_map_solidity(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
9814			{
9815		✗	BITMAP* square = create_bitmap_ex(8,16,16);
9816
9817		✗	for(int32_t i(0); i < 176; ++i)
9818			{
9819		✗	const int32_t x2 = ((i&15)<<4) + x;
9820		✗	const int32_t y2 = (i&0xF0) + y;
9821			//Blit the palette index of the solidity value.
9822			//int32_t col = (combobuf[m.data[i]].walk&15);
9823			//if ( col != 0 )
9824			//{
9825			// Z_scripterrlog("Position %d has a solidity value of %d.\n", i, col);
9826			//
9827			//}
9828		✗	clear_to_color(square,(combobuf[m.data[i]].walk&15));
9829		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
9830		✗	else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
9831			}
9832		✗	destroy_bitmap(square);
9833			}
9834
9835		✗	void do_bmpdrawscreen_solidmaskr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
9836			{
9837			//sdci[1]=layer
9838			//sdci[2]=map
9839			//sdci[3]=screen
9840			//sdci[4]=x
9841			//sdci[5]=y
9842			//sdci[6]=rotation
9843			//sdci[17] Bitmap Pointer
9844
9845		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9846		✗	if ( refbmp == NULL ) return;
9847
9848		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
9849
9850		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
9851		✗	int32_t scrn = sdci[3]/10000;
9852		✗	int32_t x = sdci[4]/10000;
9853		✗	int32_t y = sdci[5]/10000;
9854		✗	int32_t x1 = x + xoffset;
9855		✗	int32_t y1 = y + yoffset;
9856		✗	int32_t rotation = sdci[6]/10000;
9857
9858		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
9859
9860		✗	if(index >= TheMaps.size())
9861			{
9862		✗	al_trace("DrawScreen: invalid map or screen index. \n");
9863		✗	return;
9864			}
9865
9866		✗	const mapscr & m = TheMaps[index];
9867
9868
9869		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
9870		✗	if ( refbmp == NULL ) return;
9871
9872		✗	if(rotation != 0)
9873		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
9874
9875			//draw layer 0
9876		✗	draw_map_solidity(b, m, x1, y1);
9877		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
9878			{
9879		✗	for(int32_t i(0); i < 6; ++i)
9880			{
9881		✗	if(m.layermap[i] == 0) continue;
9882
9883		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
9884
9885		✗	if(layer_screen_index >= TheMaps.size())
9886		✗	continue;
9887
9888			//draw valid layers
9889		✗	draw_map_solidity(b, TheMaps[ layer_screen_index ], x1, y1);
9890			}
9891			}
9892
9893		✗	if(rotation != 0) // rotate
9894			{
9895		✗	rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
9896		✗	script_drawing_commands.ReleaseSubBitmap(b);
9897			}
9898			}
9899
9900		✗	void draw_map_solid(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
9901			{
9902		✗	BITMAP* square = create_bitmap_ex(8,16,16);
9903		✗	BITMAP* subsquare = create_bitmap_ex(8,16,16);
9904		✗	clear_to_color(subsquare,1);
9905
9906		✗	for(int32_t i(0); i < 176; ++i)
9907			{
9908		✗	const int32_t x2 = ((i&15)<<4) + x;
9909		✗	const int32_t y2 = (i&0xF0) + y;
9910			//Blit the palette index of the solidity value.
9911			//int32_t col = (combobuf[m.data[i]].walk&15);
9912			//if ( col != 0 )
9913			//{
9914			// Z_scripterrlog("Position %d has a solidity value of %d.\n", i, col);
9915			//
9916			//}
9917		✗	clear_bitmap(square);
9918		✗	int32_t sol = (combobuf[m.data[i]].walk);
9919			//al_trace("Solidity is: %d.\n", sol);
9920		✗	if ( sol & 1 )
9921			{
9922		✗	blit(subsquare, square, 0, 0, 0, 0, 8, 8);
9923			}
9924		✗	if ( sol & 2 )
9925			{
9926		✗	blit(subsquare, square, 0, 0, 0, 8, 8, 8);
9927			}
9928		✗	if ( sol & 4 )
9929			{
9930		✗	blit(subsquare, square, 0, 0, 8, 0, 8, 8);
9931			}
9932		✗	if ( sol &8 ) {
9933		✗	blit(subsquare, square, 0, 0, 8, 8, 8, 8);
9934			}
9935
9936		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
9937		✗	else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
9938			}
9939		✗	destroy_bitmap(square);
9940		✗	destroy_bitmap(subsquare);
9941			}
9942
9943		✗	void do_bmpdrawscreen_solidr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
9944			{
9945			//sdci[1]=layer
9946			//sdci[2]=map
9947			//sdci[3]=screen
9948			//sdci[4]=x
9949			//sdci[5]=y
9950			//sdci[6]=rotation
9951			//sdci[17] Bitmap Pointer
9952
9953		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
9954		✗	if ( refbmp == NULL ) return;
9955
9956		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
9957
9958		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
9959		✗	int32_t scrn = sdci[3]/10000;
9960		✗	int32_t x = sdci[4]/10000;
9961		✗	int32_t y = sdci[5]/10000;
9962		✗	int32_t x1 = x + xoffset;
9963		✗	int32_t y1 = y + yoffset;
9964		✗	int32_t rotation = sdci[6]/10000;
9965
9966		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
9967
9968		✗	if(index >= TheMaps.size())
9969			{
9970		✗	al_trace("DrawScreen: invalid map or screen index. \n");
9971		✗	return;
9972			}
9973
9974		✗	const mapscr & m = TheMaps[index];
9975
9976
9977		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
9978		✗	if ( refbmp == NULL ) return;
9979
9980		✗	if(rotation != 0)
9981		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
9982
9983			//draw layer 0
9984		✗	draw_map_solid(b, m, x1, y1);
9985
9986		✗	for(int32_t i(0); i < 6; ++i) //This one doesn't need the QR; it works just fine.
9987			{
9988		✗	if(m.layermap[i] == 0) continue;
9989
9990		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
9991
9992		✗	if(layer_screen_index >= TheMaps.size())
9993		✗	continue;
9994
9995			//draw valid layers
9996		✗	draw_map_solid(b, TheMaps[ layer_screen_index ], x1, y1);
9997			}
9998
9999		✗	if(rotation != 0) // rotate
10000			{
10001		✗	rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10002		✗	script_drawing_commands.ReleaseSubBitmap(b);
10003			}
10004			}
10005
10006		✗	void draw_map_cflag(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
10007			{
10008		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10009
10010		✗	for(int32_t i(0); i < 176; ++i)
10011			{
10012		✗	const int32_t x2 = ((i&15)<<4) + x;
10013		✗	const int32_t y2 = (i&0xF0) + y;
10014			//Blit the palette index of the solidity value.
10015		✗	clear_to_color(square,m.sflag[i]);
10016		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
10017		✗	else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
10018			}
10019		✗	destroy_bitmap(square);
10020			}
10021
10022		✗	void do_bmpdrawscreen_cflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10023			{
10024			//sdci[1]=layer
10025			//sdci[2]=map
10026			//sdci[3]=screen
10027			//sdci[4]=x
10028			//sdci[5]=y
10029			//sdci[6]=rotation
10030			//sdci[17] Bitmap Pointer
10031
10032		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10033		✗	if ( refbmp == NULL ) return;
10034
10035		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10036
10037		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10038		✗	int32_t scrn = sdci[3]/10000;
10039		✗	int32_t x = sdci[4]/10000;
10040		✗	int32_t y = sdci[5]/10000;
10041		✗	int32_t x1 = x + xoffset;
10042		✗	int32_t y1 = y + yoffset;
10043		✗	int32_t rotation = sdci[6]/10000;
10044
10045		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10046
10047		✗	if(index >= TheMaps.size())
10048			{
10049		✗	al_trace("DrawScreen: invalid map or screen index. \n");
10050		✗	return;
10051			}
10052
10053		✗	const mapscr & m = TheMaps[index];
10054
10055
10056		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10057		✗	if ( refbmp == NULL ) return;
10058
10059		✗	if(rotation != 0)
10060		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10061
10062			//draw layer 0
10063		✗	draw_map_cflag(b, m, x1, y1);
10064		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
10065			{
10066		✗	for(int32_t i(0); i < 6; ++i)
10067			{
10068		✗	if(m.layermap[i] == 0) continue;
10069
10070		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10071
10072		✗	if(layer_screen_index >= TheMaps.size())
10073		✗	continue;
10074
10075			//draw valid layers
10076		✗	draw_map_cflag(b, TheMaps[ layer_screen_index ], x1, y1);
10077			}
10078			}
10079
10080		✗	if(rotation != 0) // rotate
10081			{
10082		✗	rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10083		✗	script_drawing_commands.ReleaseSubBitmap(b);
10084			}
10085			}
10086
10087
10088		✗	void draw_map_combotype(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
10089			{
10090		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10091
10092		✗	for(int32_t i(0); i < 176; ++i)
10093			{
10094		✗	const int32_t x2 = ((i&15)<<4) + x;
10095		✗	const int32_t y2 = (i&0xF0) + y;
10096			//Blit the palette index of the solidity value.
10097		✗	clear_to_color(square,(combobuf[m.data[i]].type));
10098		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
10099		✗	else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
10100			}
10101		✗	destroy_bitmap(square);
10102			}
10103
10104		✗	void do_bmpdrawscreen_ctyper(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10105			{
10106			//sdci[1]=layer
10107			//sdci[2]=map
10108			//sdci[3]=screen
10109			//sdci[4]=x
10110			//sdci[5]=y
10111			//sdci[6]=rotation
10112			//sdci[17] Bitmap Pointer
10113
10114		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10115		✗	if ( refbmp == NULL ) return;
10116
10117		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10118
10119		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10120		✗	int32_t scrn = sdci[3]/10000;
10121		✗	int32_t x = sdci[4]/10000;
10122		✗	int32_t y = sdci[5]/10000;
10123		✗	int32_t x1 = x + xoffset;
10124		✗	int32_t y1 = y + yoffset;
10125		✗	int32_t rotation = sdci[6]/10000;
10126
10127		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10128
10129		✗	if(index >= TheMaps.size())
10130			{
10131		✗	al_trace("DrawScreen: invalid map or screen index. \n");
10132		✗	return;
10133			}
10134
10135		✗	const mapscr & m = TheMaps[index];
10136
10137
10138		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10139		✗	if ( refbmp == NULL ) return;
10140
10141		✗	if(rotation != 0)
10142		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10143
10144			//draw layer 0
10145		✗	draw_map_combotype(b, m, x1, y1);
10146
10147		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
10148			{
10149		✗	for(int32_t i(0); i < 6; ++i)
10150			{
10151		✗	if(m.layermap[i] == 0) continue;
10152
10153		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10154
10155		✗	if(layer_screen_index >= TheMaps.size())
10156		✗	continue;
10157
10158			//draw valid layers
10159		✗	draw_map_combotype(b, TheMaps[ layer_screen_index ], x1, y1);
10160			}
10161			}
10162
10163		✗	if(rotation != 0) // rotate
10164			{
10165		✗	rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10166		✗	script_drawing_commands.ReleaseSubBitmap(b);
10167			}
10168			}
10169
10170
10171		✗	void draw_map_comboiflag(BITMAP *b, const mapscr& m, int32_t x, int32_t y)
10172			{
10173		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10174
10175		✗	for(int32_t i(0); i < 176; ++i)
10176			{
10177		✗	const int32_t x2 = ((i&15)<<4) + x;
10178		✗	const int32_t y2 = (i&0xF0) + y;
10179			//Blit the palette index of the solidity value.
10180		✗	clear_to_color(square,(combobuf[m.data[i]].flag));
10181		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS)) blit(square, b, 0, 0, x2, y2, square->w, square->h);
10182		✗	else masked_blit(square, b, 0, 0, x2, y2, square->w, square->h);
10183			}
10184		✗	destroy_bitmap(square);
10185			}
10186
10187		✗	void do_bmpdrawscreen_ciflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10188			{
10189			//sdci[1]=layer
10190			//sdci[2]=map
10191			//sdci[3]=screen
10192			//sdci[4]=x
10193			//sdci[5]=y
10194			//sdci[6]=rotation
10195			//sdci[17] Bitmap Pointer
10196
10197		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10198		✗	if ( refbmp == NULL ) return;
10199
10200		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10201
10202		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10203		✗	int32_t scrn = sdci[3]/10000;
10204		✗	int32_t x = sdci[4]/10000;
10205		✗	int32_t y = sdci[5]/10000;
10206		✗	int32_t x1 = x + xoffset;
10207		✗	int32_t y1 = y + yoffset;
10208		✗	int32_t rotation = sdci[6]/10000;
10209
10210		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10211
10212		✗	if(index >= TheMaps.size())
10213			{
10214		✗	al_trace("DrawScreen: invalid map or screen index. \n");
10215		✗	return;
10216			}
10217
10218		✗	const mapscr & m = TheMaps[index];
10219
10220
10221		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10222		✗	if ( refbmp == NULL ) return;
10223
10224		✗	if(rotation != 0)
10225		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10226
10227			//draw layer 0
10228		✗	draw_map_comboiflag(b, m, x1, y1);
10229
10230		✗	if (get_bit(quest_rules, qr_BROKEN_DRAWSCREEN_FUNCTIONS))
10231			{
10232		✗	for(int32_t i(0); i < 6; ++i)
10233			{
10234		✗	if(m.layermap[i] == 0) continue;
10235
10236		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10237
10238		✗	if(layer_screen_index >= TheMaps.size())
10239		✗	continue;
10240
10241			//draw valid layers
10242		✗	draw_map_comboiflag(b, TheMaps[ layer_screen_index ], x1, y1);
10243			}
10244			}
10245
10246		✗	if(rotation != 0) // rotate
10247			{
10248		✗	rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10249		✗	script_drawing_commands.ReleaseSubBitmap(b);
10250			}
10251			}
10252
10253		✗	void do_drawlayerr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10254			{
10255			//sdci[1]=layer
10256			//sdci[2]=map
10257			//sdci[3]=screen
10258			//sdci[4]=layer
10259			//sdci[5]=x
10260			//sdci[6]=y
10261			//sdci[7]=rotation
10262			//sdci[8]=opacity
10263
10264		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10265		✗	int32_t scrn = sdci[3]/10000;
10266		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10267		✗	int32_t x = sdci[5]/10000;
10268		✗	int32_t y = sdci[6]/10000;
10269		✗	int32_t x1 = x + xoffset;
10270		✗	int32_t y1 = y + yoffset;
10271		✗	int32_t rotation = sdci[7]/10000;
10272		✗	int32_t opacity = sdci[8]/10000;
10273
10274		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10275		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10276
10277		✗	if(!m) //no need to log it.
10278		✗	return;
10279
10280		✗	if(index >= TheMaps.size())
10281			{
10282		✗	al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10283		✗	return;
10284			}
10285
10286		✗	const mapscr & l = *m;
10287
10288		✗	BITMAP* b = bmp;
10289
10290		✗	if(rotation != 0)
10291		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10292
10293
10294		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10295		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10296		✗	bool transparent = opacity <= 128;
10297
10298		✗	if(rotation != 0) // rotate
10299			{
10300		✗	draw_mapscr(b, l, x1, y1, transparent);
10301
10302		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10303		✗	script_drawing_commands.ReleaseSubBitmap(b);
10304			}
10305			else
10306			{
10307		✗	for(int32_t i(0); i < 176; ++i)
10308			{
10309		✗	const int32_t x2 = ((i&15)<<4) + x1;
10310		✗	const int32_t y2 = (i&0xF0) + y1;
10311
10312		✗	if(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY) //in clipping rect
10313			{
10314		✗	const newcombo & c = combobuf[ l.data[i] ];
10315		✗	const int32_t tile = combo_tile(c, x2, y2);
10316
10317		✗	if(opacity < 128)
10318			{
10319		✗	overcomboblocktranslucent(b, x2, y2, l.data[i], l.cset[i], 1, 1, 128);
10320
10321
10322			//overtiletranslucent16(b, tile, x2, y2, l.cset[i], c.flip, opacity);
10323			}
10324			else
10325			{
10326		✗	overcomboblock(b, x2, y2, l.data[i], l.cset[i], 1, 1);
10327			//overtile16(b, tile, x2, y2, l.cset[i], c.flip);
10328			}
10329			//putcombo( b, xx, yy, l.data[i], l.cset[i] );
10330			}
10331			}
10332			}
10333
10334			//putscr
10335			}
10336
10337
10338
10339		✗	void do_drawscreenr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10340			{
10341			//sdci[1]=layer
10342			//sdci[2]=map
10343			//sdci[3]=screen
10344			//sdci[4]=x
10345			//sdci[5]=y
10346			//sdci[6]=rotation
10347
10348		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10349		✗	int32_t scrn = sdci[3]/10000;
10350		✗	int32_t x = sdci[4]/10000;
10351		✗	int32_t y = sdci[5]/10000;
10352		✗	int32_t x1 = x + xoffset;
10353		✗	int32_t y1 = y + yoffset;
10354		✗	int32_t rotation = sdci[6]/10000;
10355
10356		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10357
10358		✗	if(index >= TheMaps.size())
10359			{
10360		✗	al_trace("DrawScreen: invalid map or screen index. \n");
10361		✗	return;
10362			}
10363
10364		✗	const mapscr & m = TheMaps[index];
10365
10366
10367		✗	BITMAP* b = bmp;
10368
10369		✗	if(rotation != 0)
10370		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10371
10372			//draw layer 0
10373		✗	draw_mapscr(b, m, x1, y1, false);
10374
10375		✗	for(int32_t i(0); i < 6; ++i)
10376			{
10377		✗	if(m.layermap[i] == 0) continue;
10378
10379		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10380
10381		✗	if(layer_screen_index >= TheMaps.size())
10382		✗	continue;
10383
10384		✗	bool trans = m.layeropacity[i] == 128;
10385
10386			//draw valid layers
10387		✗	draw_mapscr(b, TheMaps[ layer_screen_index ], x1, y1, trans);
10388			}
10389
10390		✗	if(rotation != 0) // rotate
10391			{
10392		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10393		✗	script_drawing_commands.ReleaseSubBitmap(b);
10394			}
10395			}
10396
10397
10398		✗	void do_bmpdrawlayerr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10399			{
10400			//sdci[1]=layer
10401			//sdci[2]=map
10402			//sdci[3]=screen
10403			//sdci[4]=layer
10404			//sdci[5]=x
10405			//sdci[6]=y
10406			//sdci[7]=rotation
10407			//[8] noclip
10408			//sdci[9]=opacity
10409			//sdci[17] Bitmap Pointer
10410
10411		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10412		✗	if ( refbmp == NULL ) return;
10413
10414		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10415		✗	int32_t scrn = sdci[3]/10000;
10416		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10417		✗	int32_t x = sdci[5]/10000;
10418		✗	int32_t y = sdci[6]/10000;
10419		✗	int32_t rotation = sdci[7]/10000;
10420
10421		✗	byte noclip = 0;//(sdci[8]!=0);
10422		✗	int32_t opacity = sdci[8]/10000;
10423			//zprint2("Running bmp->DrawLayer(%d, %d, %d, %d, %d, %d, %d, %d)\n", sdci[1]/10000, map, scrn, sourceLayer, x, y, rotation, opacity);
10424		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10425		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10426
10427		✗	if(!m) //no need to log it.
10428		✗	return;
10429
10430		✗	if(index >= TheMaps.size())
10431			{
10432		✗	Z_scripterrlog("DrawLayer: invalid map index \"%i\". Map count is %d.\n", index, TheMaps.size());
10433		✗	return;
10434			}
10435
10436		✗	const mapscr & l = *m;
10437
10438		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10439		✗	if ( refbmp == NULL ) return;
10440		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10441		✗	if(rotation != 0)
10442		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10443
10444
10445		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10446		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10447		✗	bool transparent = opacity <= 128;
10448
10449		✗	if(rotation != 0) // rotate
10450			{
10451		✗	draw_mapscr(b, l, x, y, transparent);
10452
10453		✗	rotate_sprite(refbmp, b, x, y, degrees_to_fixed(rotation));
10454		✗	script_drawing_commands.ReleaseSubBitmap(b);
10455			}
10456			else
10457			{
10458		✗	for(int32_t i(0); i < 176; ++i)
10459			{
10460		✗	const int32_t x2 = ((i&15)<<4) + x;
10461		✗	const int32_t y2 = (i&0xF0) + y;
10462
10463			//if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10464			{
10465		✗	const newcombo & c = combobuf[ l.data[i] ];
10466		✗	const int32_t tile = combo_tile(c, x2, y2);
10467
10468		✗	if(opacity < 128)
10469		✗	overtiletranslucent16(refbmp, tile, x2, y2, l.cset[i], c.flip, opacity);
10470			else
10471		✗	overtile16(refbmp, tile, x2, y2, l.cset[i], c.flip);
10472
10473			//putcombo( b, xx, yy, l.data[i], l.cset[i] );
10474			}
10475			}
10476			}
10477
10478			//putscr
10479			}
10480
10481
10482
10483		✗	void do_bmpdrawscreenr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10484			{
10485			//sdci[1]=layer
10486			//sdci[2]=map
10487			//sdci[3]=screen
10488			//sdci[4]=x
10489			//sdci[5]=y
10490			//sdci[6]=rotation
10491			//sdci[17] Bitmap Pointer
10492
10493		✗	BITMAP *refbmp = FFCore.GetScriptBitmap(sdci[17]-10);
10494		✗	if ( refbmp == NULL ) return;
10495
10496		✗	if ( (sdci[17]-10) != -2 && (sdci[17]-10) != -1 ) yoffset = 0; //Don't crop.
10497
10498		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10499		✗	int32_t scrn = sdci[3]/10000;
10500		✗	int32_t x = sdci[4]/10000;
10501		✗	int32_t y = sdci[5]/10000;
10502		✗	int32_t x1 = x + xoffset;
10503		✗	int32_t y1 = y + yoffset;
10504		✗	int32_t rotation = sdci[6]/10000;
10505
10506		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10507
10508		✗	if(index >= TheMaps.size())
10509			{
10510		✗	al_trace("DrawScreen: invalid map or screen index. \n");
10511		✗	return;
10512			}
10513
10514		✗	const mapscr & m = TheMaps[index];
10515
10516
10517		✗	BITMAP* b = FFCore.GetScriptBitmap(sdci[17]-10);
10518		✗	if ( refbmp == NULL ) return;
10519
10520		✗	if(rotation != 0)
10521		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10522
10523			//draw layer 0
10524		✗	draw_mapscr(b, m, x1, y1, false);
10525
10526		✗	for(int32_t i(0); i < 6; ++i)
10527			{
10528		✗	if(m.layermap[i] == 0) continue;
10529
10530		✗	uint32_t layer_screen_index = (m.layermap[i]-1) * MAPSCRS + m.layerscreen[i];
10531
10532		✗	if(layer_screen_index >= TheMaps.size())
10533		✗	continue;
10534
10535		✗	bool trans = m.layeropacity[i] == 128;
10536
10537			//draw valid layers
10538		✗	draw_mapscr(b, TheMaps[ layer_screen_index ], x1, y1, trans);
10539			}
10540
10541		✗	if(rotation != 0) // rotate
10542			{
10543		✗	rotate_sprite(refbmp, b, x1, y1, degrees_to_fixed(rotation));
10544		✗	script_drawing_commands.ReleaseSubBitmap(b);
10545			}
10546			}
10547
10548		✗	void do_bmpdrawlayersolidmaskr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10549			{
10550			//sdci[1]=layer
10551			//sdci[2]=map
10552			//sdci[3]=screen
10553			//sdci[4]=layer
10554			//sdci[5]=x
10555			//sdci[6]=y
10556			//sdci[7]=rotation
10557			//sdci[8]=bool noclip
10558			//sdci[9] == opacity
10559
10560		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10561		✗	int32_t scrn = sdci[3]/10000;
10562		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10563		✗	int32_t x = sdci[5]/10000;
10564		✗	int32_t y = sdci[6]/10000;
10565		✗	int32_t x1 = x + xoffset;
10566		✗	int32_t y1 = y + yoffset;
10567		✗	int32_t rotation = sdci[7]/10000;
10568		✗	byte noclip = (sdci[8]!=0);
10569		✗	int32_t opacity = sdci[9]/10000;
10570
10571		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10572		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10573
10574		✗	if(!m) //no need to log it.
10575		✗	return;
10576
10577		✗	if(index >= TheMaps.size())
10578			{
10579		✗	al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10580		✗	return;
10581			}
10582
10583		✗	const mapscr & l = *m;
10584
10585		✗	BITMAP* b = bmp;
10586
10587		✗	if(rotation != 0)
10588		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10589
10590
10591		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10592		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10593		✗	bool transparent = opacity <= 128;
10594
10595		✗	if(rotation != 0) // rotate
10596			{
10597		✗	draw_map_solid(b, l, x1, y1);
10598
10599		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10600		✗	script_drawing_commands.ReleaseSubBitmap(b);
10601			}
10602			else
10603			{
10604		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10605		✗	BITMAP* subsquare = create_bitmap_ex(8,16,16);
10606		✗	clear_to_color(subsquare,1);
10607		✗	for(int32_t i(0); i < 176; ++i)
10608			{
10609		✗	const int32_t x2 = ((i&15)<<4) + x1;
10610		✗	const int32_t y2 = (i&0xF0) + y1;
10611
10612		✗	if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10613			{
10614		✗	int32_t sol = (combobuf[l.data[i]].walk);
10615
10616		✗	if ( sol & 1 )
10617			{
10618		✗	blit(subsquare, square, 0, 0, 0, 0, 8, 8);
10619			}
10620		✗	if ( sol & 2 )
10621			{
10622		✗	blit(subsquare, square, 0, 0, 0, 8, 8, 8);
10623			}
10624		✗	if ( sol & 4 )
10625			{
10626		✗	blit(subsquare, square, 0, 0, 8, 0, 8, 8);
10627			}
10628		✗	if ( sol &8 ) {
10629		✗	blit(subsquare, square, 0, 0, 8, 8, 8, 8);
10630			}
10631
10632		✗	blit(square, b, 0, 0, x2, y2, square->w, square->h);
10633			}
10634			}
10635		✗	destroy_bitmap(square);
10636		✗	destroy_bitmap(subsquare);
10637			}
10638
10639			//putscr
10640			}
10641
10642		✗	void do_bmpdrawlayersolidityr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10643			{
10644			//sdci[1]=layer
10645			//sdci[2]=map
10646			//sdci[3]=screen
10647			//sdci[4]=layer
10648			//sdci[5]=x
10649			//sdci[6]=y
10650			//sdci[7]=rotation
10651			//[8] noclip
10652			//sdci[9]=opacity
10653
10654
10655		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10656		✗	int32_t scrn = sdci[3]/10000;
10657		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10658		✗	int32_t x = sdci[5]/10000;
10659		✗	int32_t y = sdci[6]/10000;
10660		✗	int32_t x1 = x + xoffset;
10661		✗	int32_t y1 = y + yoffset;
10662		✗	int32_t rotation = sdci[7]/10000;
10663		✗	byte noclip = (sdci[8]!=0);
10664		✗	int32_t opacity = sdci[9]/10000;
10665
10666		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10667		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10668
10669		✗	if(!m) //no need to log it.
10670		✗	return;
10671
10672		✗	if(index >= TheMaps.size())
10673			{
10674		✗	al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10675		✗	return;
10676			}
10677
10678		✗	const mapscr & l = *m;
10679
10680		✗	BITMAP* b = bmp;
10681
10682		✗	if(rotation != 0)
10683		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10684
10685
10686		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10687		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10688		✗	bool transparent = opacity <= 128;
10689
10690		✗	if(rotation != 0) // rotate
10691			{
10692		✗	draw_map_solidity(b, l, x1, y1);
10693
10694		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10695		✗	script_drawing_commands.ReleaseSubBitmap(b);
10696			}
10697			else
10698			{
10699		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10700		✗	for(int32_t i(0); i < 176; ++i)
10701			{
10702		✗	const int32_t x2 = ((i&15)<<4) + x1;
10703		✗	const int32_t y2 = (i&0xF0) + y1;
10704
10705		✗	if(noclip && (x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10706			{
10707		✗	clear_to_color(square,(combobuf[l.data[i]].walk&15));
10708		✗	blit(square, b, 0, 0, x2, y2, square->w, square->h);
10709			}
10710			}
10711		✗	destroy_bitmap(square);
10712			}
10713
10714			//putscr
10715			}
10716
10717		✗	void do_bmpdrawlayercflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10718			{
10719			//sdci[1]=layer
10720			//sdci[2]=map
10721			//sdci[3]=screen
10722			//sdci[4]=layer
10723			//sdci[5]=x
10724			//sdci[6]=y
10725			//sdci[7]=rotation
10726			//[8] noclip
10727			//sdci[9]=opacity
10728
10729
10730		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10731		✗	int32_t scrn = sdci[3]/10000;
10732		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10733		✗	int32_t x = sdci[5]/10000;
10734		✗	int32_t y = sdci[6]/10000;
10735		✗	int32_t x1 = x + xoffset;
10736		✗	int32_t y1 = y + yoffset;
10737		✗	int32_t rotation = sdci[7]/10000;
10738
10739		✗	byte noclip = (sdci[8]!=0);
10740		✗	int32_t opacity = sdci[9]/10000;
10741
10742		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10743		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10744
10745		✗	if(!m) //no need to log it.
10746		✗	return;
10747
10748		✗	if(index >= TheMaps.size())
10749			{
10750		✗	al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10751		✗	return;
10752			}
10753
10754		✗	const mapscr & l = *m;
10755
10756		✗	BITMAP* b = bmp;
10757
10758		✗	if(rotation != 0)
10759		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10760
10761
10762		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10763		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10764		✗	bool transparent = opacity <= 128;
10765
10766		✗	if(rotation != 0) // rotate
10767			{
10768		✗	draw_map_cflag(b, l, x1, y1);
10769
10770		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10771		✗	script_drawing_commands.ReleaseSubBitmap(b);
10772			}
10773			else
10774			{
10775		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10776		✗	for(int32_t i(0); i < 176; ++i)
10777			{
10778		✗	const int32_t x2 = ((i&15)<<4) + x1;
10779		✗	const int32_t y2 = (i&0xF0) + y1;
10780
10781		✗	if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10782			{
10783		✗	clear_to_color(square,l.sflag[i]);
10784		✗	blit(square, b, 0, 0, x2, y2, square->w, square->h);
10785			}
10786			}
10787		✗	destroy_bitmap(square);
10788			}
10789
10790			//putscr
10791			}
10792
10793		✗	void do_bmpdrawlayerctyper(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10794			{
10795			//sdci[1]=layer
10796			//sdci[2]=map
10797			//sdci[3]=screen
10798			//sdci[4]=layer
10799			//sdci[5]=x
10800			//sdci[6]=y
10801			//sdci[7]=rotation
10802			//[8] noclip
10803			//sdci[9]=opacity
10804
10805		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10806		✗	int32_t scrn = sdci[3]/10000;
10807		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10808		✗	int32_t x = sdci[5]/10000;
10809		✗	int32_t y = sdci[6]/10000;
10810		✗	int32_t x1 = x + xoffset;
10811		✗	int32_t y1 = y + yoffset;
10812		✗	int32_t rotation = sdci[7]/10000;
10813
10814		✗	byte noclip = (sdci[8]!=0);
10815		✗	int32_t opacity = sdci[9]/10000;
10816		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10817		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10818
10819		✗	if(!m) //no need to log it.
10820		✗	return;
10821
10822		✗	if(index >= TheMaps.size())
10823			{
10824		✗	al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10825		✗	return;
10826			}
10827
10828		✗	const mapscr & l = *m;
10829
10830		✗	BITMAP* b = bmp;
10831
10832		✗	if(rotation != 0)
10833		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10834
10835
10836		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10837		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10838		✗	bool transparent = opacity <= 128;
10839
10840		✗	if(rotation != 0) // rotate
10841			{
10842		✗	draw_map_combotype(b, l, x1, y1);
10843
10844		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10845		✗	script_drawing_commands.ReleaseSubBitmap(b);
10846			}
10847			else
10848			{
10849		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10850		✗	for(int32_t i(0); i < 176; ++i)
10851			{
10852		✗	const int32_t x2 = ((i&15)<<4) + x1;
10853		✗	const int32_t y2 = (i&0xF0) + y1;
10854
10855		✗	if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10856			{
10857		✗	clear_to_color(square,(combobuf[l.data[i]].type));
10858		✗	blit(square, b, 0, 0, x2, y2, square->w, square->h);
10859			}
10860			}
10861		✗	destroy_bitmap(square);
10862			}
10863
10864			//putscr
10865			}
10866
10867		✗	void do_bmpdrawlayerciflagr(BITMAP *bmp, int32_t *sdci, int32_t xoffset, int32_t yoffset, bool isOffScreen)
10868			{
10869			//sdci[1]=layer
10870			//sdci[2]=map
10871			//sdci[3]=screen
10872			//sdci[4]=layer
10873			//sdci[5]=x
10874			//sdci[6]=y
10875			//sdci[7]=rotation
10876			//[8] noclip
10877			//sdci[9]=opacity
10878
10879		✗	int32_t map = (sdci[2]/10000)-1; //zscript map indices start at 1.
10880		✗	int32_t scrn = sdci[3]/10000;
10881		✗	int32_t sourceLayer = vbound(sdci[4]/10000, 0, 6);
10882		✗	int32_t x = sdci[5]/10000;
10883		✗	int32_t y = sdci[6]/10000;
10884		✗	int32_t x1 = x + xoffset;
10885		✗	int32_t y1 = y + yoffset;
10886		✗	int32_t rotation = sdci[7]/10000;
10887		✗	byte noclip = (sdci[8]!=0);
10888		✗	int32_t opacity = sdci[9]/10000;
10889
10890		✗	const uint32_t index = (uint32_t)(map * MAPSCRS + scrn);
10891		✗	const mapscr* m = getmapscreen(map, scrn, sourceLayer);
10892
10893		✗	if(!m) //no need to log it.
10894		✗	return;
10895
10896		✗	if(index >= TheMaps.size())
10897			{
10898		✗	al_trace("DrawLayer: invalid map index \"%i\". Map count is %lu.\n", index, TheMaps.size());
10899		✗	return;
10900			}
10901
10902		✗	const mapscr & l = *m;
10903
10904		✗	BITMAP* b = bmp;
10905
10906		✗	if(rotation != 0)
10907		✗	b = script_drawing_commands.AquireSubBitmap(256, 176);
10908
10909
10910		✗	const int32_t maxX = isOffScreen ? 512 : 256;
10911		✗	const int32_t maxY = isOffScreen ? 512 : 176 + yoffset;
10912		✗	bool transparent = opacity <= 128;
10913
10914		✗	if(rotation != 0) // rotate
10915			{
10916		✗	draw_map_comboiflag(b, l, x1, y1);
10917
10918		✗	rotate_sprite(bmp, b, x1, y1, degrees_to_fixed(rotation));
10919		✗	script_drawing_commands.ReleaseSubBitmap(b);
10920			}
10921			else
10922			{
10923		✗	BITMAP* square = create_bitmap_ex(8,16,16);
10924		✗	for(int32_t i(0); i < 176; ++i)
10925			{
10926		✗	const int32_t x2 = ((i&15)<<4) + x1;
10927		✗	const int32_t y2 = (i&0xF0) + y1;
10928
10929		✗	if(noclip&&(x2 > -16 && x2 < maxX && y2 > -16 && y2 < maxY)) //in clipping rect
10930			{
10931		✗	clear_to_color(square,(combobuf[l.data[i]].flag));
10932		✗	blit(square, b, 0, 0, x2, y2, square->w, square->h);
10933			}
10934			}
10935		✗	destroy_bitmap(square);
10936			}
10937
10938			//putscr
10939			}
10940
10941
10942
10943			/////////////////////////////////////////////////////////
10944			// do primitives
10945			////////////////////////////////////////////////////////
10946
10947		18354	void do_primitives(BITMAP *targetBitmap, int32_t type, mapscr* theScreen, int32_t xoff, int32_t yoff)
10948			{
10949		18354	color_map = &trans_table2;
10950
10951			//was this next variable ever used? -- DN
10952			//bool drawsubscr=false;
10953
10954	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 18354 times.	18354	if(type > 7)
10955		✗	return;
10956	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 18354 times.	18354	if(theScreen->hidescriptlayers & (1<<type))
10957		✗	return; //Script draws hidden for this layer
10958			//--script_drawing_commands[][] reference--
10959			//[][0]: type
10960			//[][1-16]: defined by type
10961			//[][17]: unused
10962			//[][18]: rendertarget
10963			//[][19]: unused
10964
10965			// Trying to match the old behavior exactly...
10966	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 18354 times.	18354	const bool brokenOffset= ( (get_bit(extra_rules, er_BITMAPOFFSET)!=0) || (get_bit(quest_rules,qr_BITMAPOFFSETFIX)!=0) );
10967
10968		18354	bool isTargetOffScreenBmp = false;
10969		18354	const int32_t type_mul_10000 = type * 10000;
10970		18354	const int32_t numDrawCommandsToProcess = script_drawing_commands.Count();
10971		18354	FFCore.numscriptdraws = numDrawCommandsToProcess;
10972		18354	int32_t xoffset=xoff, yoffset=yoff;
10973	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 18354 times.	18354	for(int32_t i(0); i < numDrawCommandsToProcess; ++i)
10974			{
10975		✗	if(!brokenOffset)
10976			{
10977		✗	xoffset = 0;
10978		✗	yoffset = 0;
10979			}
10980		✗	int32_t *sdci = &script_drawing_commands[i][0];
10981
10982		✗	if(sdci[1] != type_mul_10000)
10983		✗	continue;
10984			// get the correct render target, if set.
10985		✗	BITMAP *bmp = zscriptDrawingRenderTarget->GetTargetBitmap(sdci[18]);
10986
10987		✗	if(!bmp)
10988			{
10989			// draw to screen with subscreen offset
10990		✗	if(!brokenOffset)
10991			{
10992		✗	xoffset = xoff;
10993		✗	yoffset = yoff;
10994			}
10995		✗	bmp = targetBitmap;
10996			}
10997			else
10998			{
10999			//not drawing to screen, so no subscreen offset
11000		✗	if(brokenOffset)
11001			{
11002		✗	xoffset = 0;
11003		✗	yoffset = 0;
11004			}
11005		✗	isTargetOffScreenBmp = true;
11006			}
11007
11008		✗	switch(sdci[0])
11009			{
11010			case RECTR:
11011			{
11012		✗	do_rectr(bmp, sdci, xoffset, yoffset);
11013			}
11014		✗	break;
11015			case FRAMER:
11016			{
11017		✗	do_framer(bmp, sdci, xoffset, yoffset);
11018			}
11019		✗	break;
11020
11021
11022			case CIRCLER:
11023			{
11024		✗	do_circler(bmp, sdci, xoffset, yoffset);
11025			}
11026		✗	break;
11027
11028			case ARCR:
11029			{
11030		✗	do_arcr(bmp, sdci, xoffset, yoffset);
11031			}
11032		✗	break;
11033
11034			case ELLIPSER:
11035			{
11036		✗	do_ellipser(bmp, sdci, xoffset, yoffset);
11037			}
11038		✗	break;
11039
11040			case LINER:
11041			{
11042		✗	do_liner(bmp, sdci, xoffset, yoffset);
11043			}
11044		✗	break;
11045
11046			case SPLINER:
11047			{
11048		✗	do_spliner(bmp, sdci, xoffset, yoffset);
11049			}
11050		✗	break;
11051
11052			case PUTPIXELR:
11053			{
11054		✗	do_putpixelr(bmp, sdci, xoffset, yoffset);
11055			}
11056		✗	break;
11057			case PIXELARRAYR:
11058			{
11059			//Z_scripterrlog("Reached case PIXELARRAYR\n");
11060		✗	do_putpixelsr(bmp, i, sdci, xoffset, yoffset);
11061			}
11062		✗	break;
11063
11064			case TILEARRAYR:
11065			{
11066			//Z_scripterrlog("Reached case PIXELARRAYR\n");
11067		✗	do_fasttilesr(bmp, i, sdci, xoffset, yoffset);
11068			}
11069		✗	break;
11070
11071			case LINESARRAY:
11072			{
11073			//Z_scripterrlog("Reached case PIXELARRAYR\n");
11074		✗	do_linesr(bmp, i, sdci, xoffset, yoffset);
11075			}
11076		✗	break;
11077
11078			case COMBOARRAYR:
11079			{
11080			//Z_scripterrlog("Reached case PIXELARRAYR\n");
11081		✗	do_fastcombosr(bmp, i, sdci, xoffset, yoffset);
11082			}
11083		✗	break;
11084
11085
11086
11087			case DRAWTILER:
11088			{
11089		✗	do_drawtiler(bmp, sdci, xoffset, yoffset);
11090			}
11091		✗	break;
11092
11093			case DRAWTILECLOAKEDR:
11094			{
11095		✗	do_drawtilecloakedr(bmp, sdci, xoffset, yoffset);
11096			}
11097		✗	break;
11098
11099			case DRAWCOMBOR:
11100			{
11101		✗	do_drawcombor(bmp, sdci, xoffset, yoffset);
11102			}
11103		✗	break;
11104
11105			case DRAWCOMBOCLOAKEDR:
11106			{
11107		✗	do_drawcombocloakedr(bmp, sdci, xoffset, yoffset);
11108			}
11109		✗	break;
11110
11111			case FASTTILER:
11112			{
11113		✗	do_fasttiler(bmp, sdci, xoffset, yoffset);
11114			}
11115		✗	break;
11116
11117			case FASTCOMBOR:
11118			{
11119		✗	do_fastcombor(bmp, sdci, xoffset, yoffset);
11120			}
11121		✗	break;
11122
11123			case DRAWCHARR:
11124			{
11125		✗	do_drawcharr(bmp, sdci, xoffset, yoffset);
11126			}
11127		✗	break;
11128
11129			case DRAWINTR:
11130			{
11131		✗	do_drawintr(bmp, sdci, xoffset, yoffset);
11132			}
11133		✗	break;
11134
11135			case DRAWSTRINGR:
11136			{
11137		✗	do_drawstringr(bmp, i, sdci, xoffset, yoffset);
11138			}
11139		✗	break;
11140
11141			case DRAWSTRINGR2:
11142			{
11143		✗	do_drawstringr2(bmp, i, sdci, xoffset, yoffset);
11144			}
11145		✗	break;
11146
11147			case QUADR:
11148			{
11149		✗	do_drawquadr(bmp, sdci, xoffset, yoffset);
11150			}
11151		✗	break;
11152
11153			case QUAD3DR:
11154			{
11155		✗	do_drawquad3dr(bmp, i, sdci, xoffset, yoffset);
11156			}
11157		✗	break;
11158
11159			case TRIANGLER:
11160			{
11161		✗	do_drawtriangler(bmp, sdci, xoffset, yoffset);
11162			}
11163		✗	break;
11164
11165			case TRIANGLE3DR:
11166			{
11167		✗	do_drawtriangle3dr(bmp, i, sdci, xoffset, yoffset);
11168			}
11169		✗	break;
11170
11171			case POLYGONR:
11172			{
11173		✗	do_polygonr(bmp, i, sdci, xoffset, yoffset);
11174			}
11175		✗	break;
11176
11177
11178			case BITMAPR:
11179			{
11180		✗	do_drawbitmapr(bmp, sdci, xoffset, yoffset);
11181			}
11182		✗	break;
11183
11184			case BITMAPEXR:
11185			{
11186		✗	do_drawbitmapexr(bmp, sdci, xoffset, yoffset);
11187			}
11188		✗	break;
11189
11190			case DRAWLAYERR:
11191			{
11192		✗	do_drawlayerr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp);
11193			}
11194		✗	break;
11195
11196			case DRAWSCREENR:
11197			{
11198		✗	do_drawscreenr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp);
11199			}
11200		✗	break;
11201
11202		✗	case BMPRECTR: bmp_do_rectr(bmp, sdci, xoffset, yoffset); break;
11203		✗	case BMPFRAMER: bmp_do_framer(bmp, sdci, xoffset, yoffset); break;
11204		✗	case BMPCIRCLER: bmp_do_circler(bmp, sdci, xoffset, yoffset); break;
11205		✗	case BMPARCR: bmp_do_arcr(bmp, sdci, xoffset, yoffset); break;
11206		✗	case BMPELLIPSER: bmp_do_ellipser(bmp, sdci, xoffset, yoffset); break;
11207		✗	case BMPLINER: bmp_do_liner(bmp, sdci, xoffset, yoffset); break;
11208		✗	case BMPSPLINER: bmp_do_spliner(bmp, sdci, xoffset, yoffset); break;
11209		✗	case BMPPUTPIXELR: bmp_do_putpixelr(bmp, sdci, xoffset, yoffset); break;
11210		✗	case BMPDRAWTILER: bmp_do_drawtiler(bmp, sdci, xoffset, yoffset); break;
11211		✗	case BMPDRAWTILECLOAKEDR: bmp_do_drawtilecloakedr(bmp, sdci, xoffset, yoffset); break;
11212		✗	case BMPDRAWCOMBOR: bmp_do_drawcombor(bmp, sdci, xoffset, yoffset); break;
11213		✗	case BMPDRAWCOMBOCLOAKEDR: bmp_do_drawcombocloakedr(bmp, sdci, xoffset, yoffset); break;
11214		✗	case BMPFASTTILER: bmp_do_fasttiler(bmp, sdci, xoffset, yoffset); break;
11215		✗	case BMPFASTCOMBOR: bmp_do_fastcombor(bmp, sdci, xoffset, yoffset); break;
11216		✗	case BMPDRAWCHARR: bmp_do_drawcharr(bmp, sdci, xoffset, yoffset); break;
11217		✗	case BMPDRAWINTR: bmp_do_drawintr(bmp, sdci, xoffset, yoffset); break;
11218		✗	case BMPDRAWSTRINGR: bmp_do_drawstringr(bmp, i, sdci, xoffset, yoffset); break;
11219		✗	case BMPDRAWSTRINGR2: bmp_do_drawstringr2(bmp, i, sdci, xoffset, yoffset); break;
11220		✗	case BMPQUADR: bmp_do_drawquadr(bmp, sdci, xoffset, yoffset); break;
11221		✗	case BMPQUAD3DR: bmp_do_drawquad3dr(bmp, i, sdci, xoffset, yoffset); break;
11222
11223		✗	case BITMAPGETPIXEL: bmp_do_getpixelr(bmp, sdci, xoffset, yoffset); break;
11224		✗	case BMPTRIANGLER: bmp_do_drawtriangler(bmp, sdci, xoffset, yoffset); break;
11225		✗	case BMPTRIANGLE3DR: bmp_do_drawtriangle3dr(bmp, i, sdci, xoffset, yoffset); break;
11226		✗	case BMPPOLYGONR: bmp_do_polygonr(bmp, i, sdci, xoffset, yoffset); break;
11227		✗	case BMPDRAWLAYERR: do_bmpdrawlayerr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11228		✗	case BMPDRAWSCREENR: do_bmpdrawscreenr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11229		✗	case BMPDRAWSCREENSOLIDR: do_bmpdrawscreen_solidmaskr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11230		✗	case BMPDRAWSCREENSOLID2R: do_bmpdrawscreen_solidr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11231		✗	case BMPDRAWSCREENCOMBOFR: do_bmpdrawscreen_cflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11232		✗	case BMPDRAWSCREENCOMBOIR: do_bmpdrawscreen_ciflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11233		✗	case BMPDRAWSCREENCOMBOTR: do_bmpdrawscreen_ctyper(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11234		✗	case BMPBLIT: bmp_do_drawbitmapexr(bmp, sdci, xoffset, yoffset); break;
11235		✗	case BMPMODE7: bmp_do_mode7r(bmp, sdci, xoffset, yoffset); break;
11236		✗	case BMPBLITTO: bmp_do_blittor(bmp, sdci, xoffset, yoffset); break;
11237		✗	case READBITMAP: bmp_do_readr(bmp, i, sdci, xoffset, yoffset); break;
11238		✗	case WRITEBITMAP: bmp_do_writer(bmp, i, sdci, xoffset, yoffset); break;
11239		✗	case CLEARBITMAP: bmp_do_clearr(bmp, sdci, xoffset, yoffset); break;
11240		✗	case BITMAPCLEARTOCOLOR: bmp_do_clearcolorr(bmp, sdci, xoffset, yoffset); break;
11241		✗	case REGENERATEBITMAP: bmp_do_regenr(bmp, sdci, xoffset, yoffset); break;
11242
11243		✗	case BMPDRAWLAYERSOLIDR: do_bmpdrawlayersolidmaskr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11244		✗	case BMPDRAWLAYERCFLAGR: do_bmpdrawlayercflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11245		✗	case BMPDRAWLAYERCTYPER: do_bmpdrawlayerctyper(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11246		✗	case BMPDRAWLAYERCIFLAGR: do_bmpdrawlayerciflagr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11247		✗	case BMPDRAWLAYERSOLIDITYR: do_bmpdrawlayersolidityr(bmp, sdci, xoffset, yoffset, isTargetOffScreenBmp); break;
11248		✗	case BMPWRITETILE: do_bmpwritetile(bmp, sdci, xoffset, yoffset); break;
11249		✗	case BMPDITHER: do_bmpdither(bmp, sdci, xoffset, yoffset); break;
11250		✗	case BMPREPLCOLOR: do_bmpreplcol(bmp, sdci, xoffset, yoffset); break;
11251		✗	case BMPSHIFTCOLOR: do_bmpshiftcol(bmp, sdci, xoffset, yoffset); break;
11252		✗	case BMPMASKDRAW: do_bmpmaskdraw(bmp, sdci, xoffset, yoffset); break;
11253		✗	case BMPMASKBLIT: do_bmpmaskblit(bmp, sdci, xoffset, yoffset); break;
11254			}
11255			}
11256
11257
11258		18354	color_map=&trans_table;
11259		18354	}
11260
11261		2089	void CScriptDrawingCommands::Clear()
11262			{
11263		2089	scb.update();
11264	1/2 ✓ Branch 0 taken 2089 times. ✗ Branch 1 not taken.	2089	if(commands.empty())
11265		2089	return;
11266
11267			//only clear what was used.
11268		✗	memset((void*)&commands[0], 0, count * sizeof(CScriptDrawingCommandVars));
11269		✗	count = 0;
11270
11271		✗	draw_container.Clear();
11272		2089	}
11273		✗	CScriptDrawingCommands* CScriptDrawingCommands::pop_commands()
11274			{
11275		✗	CScriptDrawingCommands* ret = new CScriptDrawingCommands();
11276		✗	if(commands.empty())
11277		✗	return ret;
11278		✗	ret->push_commands(this, false);
11279
11280		✗	memset((void*)&commands[0], 0, count * sizeof(CScriptDrawingCommandVars));
11281		✗	count = 0;
11282
11283		✗	draw_container.Clear();
11284		✗	return ret;
11285			}
11286		✗	void CScriptDrawingCommands::push_commands(CScriptDrawingCommands* other, bool del)
11287			{
11288		✗	commands.insert(commands.end(), other->commands.begin(), other->commands.end());
11289		✗	count += other->count;
11290		✗	if(del) delete other;
11291			}
11292
11293		✗	void do_script_draws(BITMAP *targetBitmap, mapscr* theScreen, int32_t xoff, int32_t yoff, bool hideLayer7)
11294			{
11295		✗	if(XOR(theScreen->flags7&fLAYER2BG, DMaps[currdmap].flags&dmfLAYER2BG)) do_primitives(targetBitmap, 2, theScreen, xoff, yoff);
11296		✗	if(XOR(theScreen->flags7&fLAYER3BG, DMaps[currdmap].flags&dmfLAYER3BG)) do_primitives(targetBitmap, 3, theScreen, xoff, yoff);
11297		✗	do_primitives(targetBitmap, 0, theScreen, xoff, yoff);
11298		✗	do_primitives(targetBitmap, 1, theScreen, xoff, yoff);
11299		✗	if(!XOR(theScreen->flags7&fLAYER2BG, DMaps[currdmap].flags&dmfLAYER2BG)) do_primitives(targetBitmap, 2, theScreen, xoff, yoff);
11300		✗	if(!XOR(theScreen->flags7&fLAYER3BG, DMaps[currdmap].flags&dmfLAYER3BG)) do_primitives(targetBitmap, 3, theScreen, xoff, yoff);
11301		✗	do_primitives(targetBitmap, 4, theScreen, xoff, yoff);
11302		✗	do_primitives(targetBitmap, 5, theScreen, xoff, yoff);
11303		✗	do_primitives(targetBitmap, 6, theScreen, xoff, yoff);
11304		✗	if(!hideLayer7) do_primitives(targetBitmap, 7, theScreen, xoff, yoff);
11305			}
11306